Ticket #2321: SATRewrite.patch

Wed Jun 11 13:54:48 BST 2008  Max Bolingbroke <batterseapower@hotmail.com>
  * Initial SAT fix

Wed Jun 11 20:35:35 BST 2008  Max Bolingbroke <batterseapower@hotmail.com>
  * SAT rewrite to fix #2321

New patches:

[Initial SAT fix
Max Bolingbroke <batterseapower@hotmail.com>**20080611125448] {
hunk ./compiler/main/DynFlags.hs 836
-    -- static_args   = dopt Opt_StaticArgumentTransformation dflags
+    static_args   = dopt Opt_StaticArgumentTransformation dflags
hunk ./compiler/main/DynFlags.hs 890
-           -- runWhen static_args CoreDoStaticArgs,
-            -- XXX disabled, see #2321
+           runWhen static_args (CoreDoPasses [ simpl_gently, CoreDoStaticArgs ]),
hunk ./compiler/simplCore/SAT.lhs 7
-               Static Argument Transformation pass
+                                Static Argument Transformation pass
hunk ./compiler/simplCore/SAT.lhs 38
-       should_transform 
+                should_transform
hunk ./compiler/simplCore/SAT.lhs 56
-import Var
+import Var hiding (mkLocalId)
hunk ./compiler/simplCore/SAT.lhs 60
+import CoreUtils
hunk ./compiler/simplCore/SAT.lhs 67
+import Name
hunk ./compiler/simplCore/SAT.lhs 70
-import Panic
hunk ./compiler/simplCore/SAT.lhs 82
-    sat_bind_threaded_us us bind = 
-        let (us1, us2) = splitUniqSupply us 
+    sat_bind_threaded_us us bind =
+        let (us1, us2) = splitUniqSupply us
hunk ./compiler/simplCore/SAT.lhs 168
-        
+
hunk ./compiler/simplCore/SAT.lhs 188
-       Environment
+                Environment
hunk ./compiler/simplCore/SAT.lhs 238
-       Static Argument Transformation Monad
+                Static Argument Transformation Monad
hunk ./compiler/simplCore/SAT.lhs 258
-  = SatM $ \us env -> 
+  = SatM $ \us env ->
hunk ./compiler/simplCore/SAT.lhs 286
-               Utility Functions
+                                Utility Functions
hunk ./compiler/simplCore/SAT.lhs 294
-newSATName :: Id -> Type -> SatM Id
-newSATName _ ty
-  = SatM $ \us env -> (mkSysLocal (fsLit "$sat") (uniqFromSupply us) ty, env)
+newSATName :: SatM Name
+newSATName = SatM $ \us env ->
+                     (mkSystemVarName (uniqFromSupply us) (fsLit "$sat"), env)
hunk ./compiler/simplCore/SAT.lhs 308
-We implement saTransform using shadowing of binders, that is
-we transform
-map = \f as -> case as of
-         [] -> []
-         (a':as') -> let x = f a'
-                 y = map f as'
-                 in x:y
+To do the transformation, the game plan is to:
+
+1. Create a small nonrecursive RHS that takes the
+   original arguments to the function but discards
+   the ones that are static and makes a call to the
+   SATed version with the remainder. We intend that
+   this will be inlined later, removing the overhead
+
+2. Bind this nonrecursive RHS over the original body
+   WITH THE SAME UNIQUE as the original body so that
+   any recursive calls to the original now go via
+   the small wrapper
+
+3. Rebind the original function to a new one which contains
+   our SATed function and just makes a call to it:
+   we call the thing making this call the local body
+
+Example: transform this
+
+    map :: forall a b. (a->b) -> [a] -> [b]
+    map = /\ab. \f as -> body[map]
hunk ./compiler/simplCore/SAT.lhs 330
-map = \f as -> let map = \f as -> map' as
-           in let rec map' = \as -> case as of
-                      [] -> []
-                      (a':as') -> let x = f a'
-                              y = map f as'
-                              in x:y
-          in map' as
+    map :: forall a b. (a->b) -> [a] -> [b]
+    map = /\ab. \f as ->
+         letrec map' :: [a] -> [b]
+                                map' = \as -> let map = /\ab. \f as -> map' as
+                              in body[map]
+         in map' as
+
+Note [Shadow binding]
+~~~~~~~~~~~~~~~~~~~~~
+The calls to the inner map inside body[map] should get inlined
+by the local re-binding of 'map'.  We call this the "shadow binding".
+
+But we can't use the original binder 'map' unchanged, because
+it might be exported, in which case the shadow binding won't be
+discarded as dead code after it is inlined.
hunk ./compiler/simplCore/SAT.lhs 346
-the inner map should get inlined and eliminated.
+So we use a hack: we make a new SysLocal binder with the *same* unique
+as binder.  (Another alternative would be to reset the export flag.)
hunk ./compiler/simplCore/SAT.lhs 354
-      Just (tyargs, args) | should_transform args
+      Just (_, args) | should_transform args
hunk ./compiler/simplCore/SAT.lhs 358
-            binder' <- newSATName binder (mkSATLamTy tyargs args)
-            new_rhs <- mkNewRhs binder binder' args rhs
+            sat_name <- newSATName
+            let new_rhs = mkNewRhs sat_name args
hunk ./compiler/simplCore/SAT.lhs 364
-      = staticArgsLength > 1           -- THIS IS THE DECISION POINT
+      = staticArgsLength > 1                              -- THIS IS THE DECISION POINT
hunk ./compiler/simplCore/SAT.lhs 366
-    
-    mkNewRhs binder binder' args rhs = let
-        non_static_args :: [Id]
+
+    (rhs_binders, rhs_body) = collectBinders rhs
+    rhs_val_binders = filter isId rhs_binders
+
+    mkNewRhs name' args
+      = mkLams rhs_binders $
+                Let (Rec [(bndr', rec_body)]) {-in-} local_body
+      where
+        non_static_args :: [Var]
hunk ./compiler/simplCore/SAT.lhs 383
-        -- To do the transformation, the game plan is to:
-        -- 1. Create a small nonrecursive RHS that takes the
-        --    original arguments to the function but discards
-        --    the ones that are static and makes a call to the
-        --    SATed version with the remainder. We intend that
-        --    this will be inlined later, removing the overhead
-        -- 2. Bind this nonrecursive RHS over the original body
-        --    WITH THE SAME UNIQUE as the original body so that
-        --    any recursive calls to the original now go via
-        --    the small wrapper
-        -- 3. Rebind the original function to a new one which contains
-        --    our SATed function and just makes a call to it:
-        --    we call the thing making this call the local body
-
-        local_body = mkApps (Var binder') [Var a | a <- non_static_args]
-
-        nonrec_rhs = mkOrigLam local_body
-
-        -- HACK! The following is a fake SysLocal binder with
-        --  *the same* unique as binder.
-        -- the reason for this is the following:
-        -- this binder *will* get inlined but if it happen to be
-        -- a top level binder it is never removed as dead code,
-        -- therefore we have to remove that information (of it being
-        -- top-level or exported somehow.)
-        -- A better fix is to use binder directly but with the TopLevel
-        -- tag (or Exported tag) modified.
-        fake_binder = mkSysLocal (fsLit "sat")
-                (getUnique binder)
-                (idType binder)
-        rec_body = mkLams non_static_args
-                   (Let (NonRec fake_binder nonrec_rhs) {-in-} rhs_body)
-        in return (mkOrigLam (Let (Rec [(binder', rec_body)]) {-in-} local_body))
-      where
-        (rhs_binders, rhs_body) = collectBinders rhs
-        rhs_val_binders = filter isId rhs_binders
-        
-        mkOrigLam = mkLams rhs_binders
-
-    mkSATLamTy tyargs args
-      = substTy (mk_inst_tyenv tyargs tv_tmpl)
-                (mkSigmaTy tv_tmpl' theta_tys' tau_ty')
-      where
-          -- get type info for the local function:
-          (tv_tmpl, theta_tys, tau_ty) = (tcSplitSigmaTy . idType) binder
-          (reg_arg_tys, res_type)      = splitFunTys tau_ty
-
-          -- now, we drop the ones that are
-          -- static, that is, the ones we will not pass to the local function
-          tv_tmpl'     = dropStatics tyargs tv_tmpl
+        bndr' = mkLocalId name' (exprType rec_body)
hunk ./compiler/simplCore/SAT.lhs 385
-          -- Extract the args that correspond to the theta tys (e.g. dictionaries) and argument tys (normal values)
-          (args1, args2) = splitAtList theta_tys args
-          theta_tys'     = dropStatics args1 theta_tys
-          reg_arg_tys'   = dropStatics args2 reg_arg_tys
+        rec_body = mkLams non_static_args $
+                    Let (NonRec shadow_binder nonrec_rhs) rhs_body
+        nonrec_rhs = mkLams rhs_binders local_body
+        local_body = mkVarApps (Var bndr') non_static_args
hunk ./compiler/simplCore/SAT.lhs 390
-          -- Piece the function type back together from our static-filtered components
-          tau_ty'        = mkFunTys reg_arg_tys' res_type
hunk ./compiler/simplCore/SAT.lhs 391
-          mk_inst_tyenv :: [Staticness Type] -> [TyVar] -> TvSubst
-          mk_inst_tyenv []              _      = emptyTvSubst
-          mk_inst_tyenv (Static s:args) (t:ts) = extendTvSubst (mk_inst_tyenv args ts) t s
-          mk_inst_tyenv (_:args)        (_:ts) = mk_inst_tyenv args ts
-          mk_inst_tyenv _               _      = panic "mk_inst_tyenv"
-
-dropStatics :: [Staticness a] -> [b] -> [b]
-dropStatics [] t = t
-dropStatics (Static _:args) (_:ts) = dropStatics args ts
-dropStatics (_:args)        (t:ts) = t:dropStatics args ts
-dropStatics _               _      = panic "dropStatics"
+        -- See Note [Shadow binding]
+        shadow_binder = mkSysLocal (fsLit "sat") (getUnique binder) (idType binder)
hunk ./compiler/simplCore/SAT.lhs 398
-
}

[SAT rewrite to fix #2321
Max Bolingbroke <batterseapower@hotmail.com>**20080611193535] {
hunk ./compiler/simplCore/SAT.lhs 57
-import VarEnv
hunk ./compiler/simplCore/SAT.lhs 67
+import FiniteMap
+import VarSet
+import UniqSet
+import Outputable
hunk ./compiler/simplCore/SAT.lhs 87
-        in (us1, runSAT (satBind bind) us2)
+        in (us1, fst $ runSAT (satBind bind emptyUniqSet) us2)
hunk ./compiler/simplCore/SAT.lhs 94
-satBind :: CoreBind -> SatM CoreBind
-satBind (NonRec binder expr) = do
-    expr' <- satExpr expr
-    return (NonRec binder expr')
-satBind (Rec [(binder, rhs)]) = do
-    insSAEnvFromBinding binder rhs
-    rhs' <- satExpr rhs
-    saTransform binder rhs'
-satBind (Rec pairs) = do
+satBind :: CoreBind -> IdSet -> SatM (CoreBind, IdSATInfo)
+satBind (NonRec binder expr) interesting_ids = do
+    (expr', sat_info_expr, expr_app) <- satExpr expr interesting_ids
+    return (NonRec binder expr', finalizeApp expr_app sat_info_expr)
+satBind (Rec [(binder, rhs)]) interesting_ids = do
+    let interesting_ids' = interesting_ids `addOneToUniqSet` binder
+        (rhs_binders, rhs_body) = collectBinders rhs
+    (rhs_body', sat_info_rhs_body) <- satTopLevelExpr rhs_body interesting_ids'
+    let sat_info_rhs_from_args = unitFM binder (bindersToSATInfo rhs_binders)
+        sat_info_rhs' = mergeIdSATInfo sat_info_rhs_from_args sat_info_rhs_body
+        
+        shadowing = binder `elementOfUniqSet` interesting_ids
+        sat_info_rhs'' = if shadowing
+                        then sat_info_rhs' `delFromFM` binder -- For safety
+                        else sat_info_rhs'
+    
+    us <- getUniqs 
+    let bind' = saTransformMaybe us binder (lookupFM sat_info_rhs' binder) rhs_binders rhs_body'
+    return (bind', sat_info_rhs'')
+satBind (Rec pairs) interesting_ids = do
hunk ./compiler/simplCore/SAT.lhs 115
-    rhss' <- mapM satExpr rhss
-    return (Rec (zipEqual "satBind" binders rhss'))
+    rhss_SATed <- mapM (\e -> satTopLevelExpr e interesting_ids) rhss
+    let (rhss', sat_info_rhss') = unzip rhss_SATed
+    return (Rec (zipEqual "satBind" binders rhss'), mergeIdSATInfos sat_info_rhss')
hunk ./compiler/simplCore/SAT.lhs 120
-emptySATInfo :: Id -> Maybe (Id, SATInfo)
-emptySATInfo v = Just (v, ([], []))
-
-satExpr :: CoreExpr -> SatM CoreExpr
-satExpr var@(Var v) = do
-    updSAEnv (emptySATInfo v)
-    return var
-
-satExpr lit@(Lit _) = do
-    return lit
-
-satExpr (Lam binders body) = do
-    body' <- satExpr body
-    return (Lam binders body')
+data App = VarApp Id | TypeApp Type
+data Staticness a = Static a | NotStatic
hunk ./compiler/simplCore/SAT.lhs 123
-satExpr app@(App _ _) = do
-    getAppArgs app
+type IdAppInfo = (Id, SATInfo)
hunk ./compiler/simplCore/SAT.lhs 125
-satExpr (Case expr bndr ty alts) = do
-    expr' <- satExpr expr
-    alts' <- mapM satAlt alts
-    return (Case expr' bndr ty alts')
-  where
-    satAlt (con, bndrs, expr) = do
-        expr' <- satExpr expr
-        return (con, bndrs, expr')
+type SATInfo = [Staticness App]
+type IdSATInfo = FiniteMap Id SATInfo
hunk ./compiler/simplCore/SAT.lhs 128
-satExpr (Let bind body) = do
-    body' <- satExpr body
-    bind' <- satBind bind
-    return (Let bind' body')
+{-
+pprIdSATInfo id_sat_info = vcat (map pprIdAndSATInfo (fmToList id_sat_info))
+  where pprIdAndSATInfo (v, sat_info) = hang (ppr v <> colon) 4 (pprSATInfo sat_info)
+-}
hunk ./compiler/simplCore/SAT.lhs 133
-satExpr (Note note expr) = do
-    expr' <- satExpr expr
-    return (Note note expr')
+pprSATInfo :: SATInfo -> SDoc
+pprSATInfo staticness = hcat $ map pprStaticness staticness
hunk ./compiler/simplCore/SAT.lhs 136
-satExpr ty@(Type _) = do
-    return ty
+pprStaticness :: Staticness App -> SDoc
+pprStaticness (Static (VarApp _))  = ptext (sLit "SV") 
+pprStaticness (Static (TypeApp _)) = ptext (sLit "ST") 
+pprStaticness NotStatic            = ptext (sLit "NS")
hunk ./compiler/simplCore/SAT.lhs 141
-satExpr (Cast expr coercion) = do
-    expr' <- satExpr expr
-    return (Cast expr' coercion)
-\end{code}
hunk ./compiler/simplCore/SAT.lhs 142
-\begin{code}
-getAppArgs :: CoreExpr -> SatM CoreExpr
-getAppArgs app = do
-    (app', result) <- get app
-    updSAEnv result
-    return app'
-  where
-    get :: CoreExpr -> SatM (CoreExpr, Maybe (Id, SATInfo))
-    get (App e (Type ty)) = do
-        (e', result) <- get e
-        return
-            (App e' (Type ty),
-            case result of
-                Nothing            -> Nothing
-                Just (v, (tv, lv)) -> Just (v, (tv ++ [Static ty], lv)))
+mergeSATInfo :: SATInfo -> SATInfo -> SATInfo
+mergeSATInfo [] _  = []
+mergeSATInfo _  [] = []
+mergeSATInfo (NotStatic:statics) (_:apps) = NotStatic : mergeSATInfo statics apps
+mergeSATInfo (_:statics) (NotStatic:apps) = NotStatic : mergeSATInfo statics apps
+mergeSATInfo ((Static (VarApp v)):statics)  ((Static (VarApp v')):apps)  = (if v == v' then Static (VarApp v) else NotStatic) : mergeSATInfo statics apps
+mergeSATInfo ((Static (TypeApp t)):statics) ((Static (TypeApp t')):apps) = (if t `coreEqType` t' then Static (TypeApp t) else NotStatic) : mergeSATInfo statics apps
+mergeSATInfo l  r  = pprPanic "mergeSATInfo" $ ptext (sLit "Left:") <> pprSATInfo l <> ptext (sLit ", ")
+                                            <> ptext (sLit "Right:") <> pprSATInfo r
hunk ./compiler/simplCore/SAT.lhs 152
-    get (App e a) = do
-        (e', result) <- get e
-        a' <- satExpr a
+mergeIdSATInfo :: IdSATInfo -> IdSATInfo -> IdSATInfo
+mergeIdSATInfo = plusFM_C mergeSATInfo
hunk ./compiler/simplCore/SAT.lhs 155
-        let si = case a' of
-                    Var v -> Static v
-                    _     -> NotStatic
-        return
-            (App e' a',
-            case result of
-                Just (v, (tv, lv))  -> Just (v, (tv, lv ++ [si]))
-                Nothing             -> Nothing)
+mergeIdSATInfos :: [IdSATInfo] -> IdSATInfo
+mergeIdSATInfos = foldl1' mergeIdSATInfo
hunk ./compiler/simplCore/SAT.lhs 158
-    get var@(Var v) = do
-        return (var, emptySATInfo v)
+bindersToSATInfo :: [Id] -> SATInfo
+bindersToSATInfo vs = map (Static . binderToApp) vs
+    where binderToApp v = if isId v
+                          then VarApp v
+                          else TypeApp $ mkTyVarTy v
hunk ./compiler/simplCore/SAT.lhs 164
-    get e = do
-        e' <- satExpr e
-        return (e', Nothing)
+finalizeApp :: Maybe IdAppInfo -> IdSATInfo -> IdSATInfo
+finalizeApp Nothing id_sat_info = id_sat_info
+finalizeApp (Just (v, sat_info')) id_sat_info = 
+    let sat_info'' = case lookupFM id_sat_info v of
+                        Nothing -> sat_info'
+                        Just sat_info -> mergeSATInfo sat_info sat_info'
+    in addToFM id_sat_info v sat_info''
hunk ./compiler/simplCore/SAT.lhs 172
-
-%************************************************************************
-
-                Environment
-
-%************************************************************************
-
hunk ./compiler/simplCore/SAT.lhs 173
-data SATEnv = SatEnv { idSATInfo :: IdEnv SATInfo }
+satTopLevelExpr :: CoreExpr -> IdSet -> SatM (CoreExpr, IdSATInfo)
+satTopLevelExpr expr interesting_ids = do
+    (expr', sat_info_expr, expr_app) <- satExpr expr interesting_ids
+    return (expr', finalizeApp expr_app sat_info_expr)
hunk ./compiler/simplCore/SAT.lhs 178
-emptyEnv :: SATEnv
-emptyEnv = SatEnv { idSATInfo = emptyVarEnv }
+satExpr :: CoreExpr -> IdSet -> SatM (CoreExpr, IdSATInfo, Maybe IdAppInfo)
+satExpr var@(Var v) interesting_ids = do
+    let app_info = if v `elementOfUniqSet` interesting_ids
+                   then Just (v, [])
+                   else Nothing
+    return (var, emptyFM, app_info)
hunk ./compiler/simplCore/SAT.lhs 185
-type SATInfo = ([Staticness Type], [Staticness Id])
+satExpr lit@(Lit _) _ = do
+    return (lit, emptyFM, Nothing)
hunk ./compiler/simplCore/SAT.lhs 188
-data Staticness a = Static a | NotStatic
+satExpr (Lam binders body) interesting_ids = do
+    (body', sat_info, this_app) <- satExpr body interesting_ids
+    return (Lam binders body', finalizeApp this_app sat_info, Nothing)
hunk ./compiler/simplCore/SAT.lhs 192
-delOneFromSAEnv :: Id -> SatM ()
-delOneFromSAEnv v = modifyEnv $ \env -> env { idSATInfo = delVarEnv (idSATInfo env) v }
+satExpr (App fn arg) interesting_ids = do
+    (fn', sat_info_fn, fn_app) <- satExpr fn interesting_ids
+    let satRemainder = boring fn' sat_info_fn
+    case fn_app of
+        Nothing -> satRemainder Nothing
+        Just (fn_id, fn_app_info) ->
+            -- TODO: remove this use of append somehow (use a data structure with O(1) append but a left-to-right kind of interface)
+            let satRemainderWithStaticness arg_staticness = satRemainder $ Just (fn_id, fn_app_info ++ [arg_staticness])
+            in case arg of
+                Type t -> satRemainderWithStaticness $ Static (TypeApp t)
+                Var v  -> satRemainderWithStaticness $ Static (VarApp v)
+                _      -> satRemainderWithStaticness $ NotStatic
+  where
+    boring :: CoreExpr -> IdSATInfo -> Maybe IdAppInfo -> SatM (CoreExpr, IdSATInfo, Maybe IdAppInfo)
+    boring fn' sat_info_fn app_info = 
+        do (arg', sat_info_arg, arg_app) <- satExpr arg interesting_ids
+           let sat_info_arg' = finalizeApp arg_app sat_info_arg
+               sat_info = mergeIdSATInfo sat_info_fn sat_info_arg'
+           return (App fn' arg', sat_info, app_info)
hunk ./compiler/simplCore/SAT.lhs 212
-updSAEnv :: Maybe (Id, SATInfo) -> SatM ()
-updSAEnv Nothing = do
-    return ()
-updSAEnv (Just (b, (tyargs, args))) = do
-    r <- getSATInfo b
-    case r of
-      Nothing               -> return ()
-      Just (tyargs', args') -> do
-          delOneFromSAEnv b
-          insSAEnv b (checkArgs (eqWith coreEqType) tyargs tyargs',
-                      checkArgs (eqWith (==)) args args')
-  where eqWith _  NotStatic  NotStatic  = True
-        eqWith eq (Static x) (Static y) = x `eq` y
-        eqWith _  _          _          = False
+satExpr (Case expr bndr ty alts) interesting_ids = do
+    (expr', sat_info_expr, expr_app) <- satExpr expr interesting_ids
+    let sat_info_expr' = finalizeApp expr_app sat_info_expr
+    
+    zipped_alts' <- mapM satAlt alts
+    let (alts', sat_infos_alts) = unzip zipped_alts'
+    return (Case expr' bndr ty alts', mergeIdSATInfo sat_info_expr' (mergeIdSATInfos sat_infos_alts), Nothing)
+  where
+    satAlt (con, bndrs, expr) = do
+        (expr', sat_info_expr) <- satTopLevelExpr expr interesting_ids
+        return ((con, bndrs, expr'), sat_info_expr)
hunk ./compiler/simplCore/SAT.lhs 224
-checkArgs :: (Staticness a -> Staticness a -> Bool) -> [Staticness a] -> [Staticness a] -> [Staticness a]
-checkArgs _  as [] = notStatics (length as)
-checkArgs _  [] as = notStatics (length as)
-checkArgs eq (a:as) (a':as') | a `eq` a' = a:checkArgs eq as as'
-checkArgs eq (_:as) (_:as') = NotStatic:checkArgs eq as as'
+satExpr (Let bind body) interesting_ids = do
+    (body', sat_info_body, body_app) <- satExpr body interesting_ids
+    (bind', sat_info_bind) <- satBind bind interesting_ids
+    return (Let bind' body', mergeIdSATInfo sat_info_body sat_info_bind, body_app)
hunk ./compiler/simplCore/SAT.lhs 229
-notStatics :: Int -> [Staticness a]
-notStatics n = nOfThem n NotStatic
+satExpr (Note note expr) interesting_ids = do
+    (expr', sat_info_expr, expr_app) <- satExpr expr interesting_ids
+    return (Note note expr', sat_info_expr, expr_app)
hunk ./compiler/simplCore/SAT.lhs 233
-insSAEnv :: Id -> SATInfo -> SatM ()
-insSAEnv b info = modifyEnv $ \env -> env { idSATInfo = extendVarEnv (idSATInfo env) b info }
+satExpr ty@(Type _) _ = do
+    return (ty, emptyFM, Nothing)
hunk ./compiler/simplCore/SAT.lhs 236
-insSAEnvFromBinding :: Id -> CoreExpr -> SatM ()
-insSAEnvFromBinding bndr e = insSAEnv bndr (getArgLists e)
+satExpr (Cast expr coercion) interesting_ids = do
+    (expr', sat_info_expr, expr_app) <- satExpr expr interesting_ids
+    return (Cast expr' coercion, sat_info_expr, expr_app)
hunk ./compiler/simplCore/SAT.lhs 247
-Two items of state to thread around: a UniqueSupply and a SATEnv.
+Thread around a UniqueSupply
hunk ./compiler/simplCore/SAT.lhs 251
-  = SatM (UniqSupply -> SATEnv -> (result, SATEnv))
+  = SatM (UniqSupply -> result)
hunk ./compiler/simplCore/SAT.lhs 259
-runSAT (SatM f) us = fst $ f us emptyEnv
+runSAT (SatM f) us = f us
hunk ./compiler/simplCore/SAT.lhs 263
-  = SatM $ \us env ->
+  = SatM $ \us ->
hunk ./compiler/simplCore/SAT.lhs 265
-    case m s1 env              of { (m_result, menv) ->
+    case m s1                  of { m_result ->
hunk ./compiler/simplCore/SAT.lhs 267
-    k' s2 menv }}}
+    k' s2 }}}
hunk ./compiler/simplCore/SAT.lhs 271
-  = SatM $ \us env ->
+  = SatM $ \us ->
hunk ./compiler/simplCore/SAT.lhs 273
-    case m s1 env               of { (_, menv) ->
-    k s2 menv }}
+    case m s1                  of { _ ->
+    k s2 }}
hunk ./compiler/simplCore/SAT.lhs 277
-returnSAT v = withEnv $ \env -> (v, env)
-
-modifyEnv :: (SATEnv -> SATEnv) -> SatM ()
-modifyEnv f = SatM $ \_ env -> ((), f env)
-
-withEnv :: (SATEnv -> (b, SATEnv)) -> SatM b
-withEnv f = SatM $ \_ env -> f env
-
-projectFromEnv :: (SATEnv -> a) -> SatM a
-projectFromEnv f = withEnv (\env -> (f env, env))
-\end{code}
-
-%************************************************************************
-
-                                Utility Functions
-
-%************************************************************************
-
-\begin{code}
-getSATInfo :: Id -> SatM (Maybe SATInfo)
-getSATInfo var = projectFromEnv $ \env -> lookupVarEnv (idSATInfo env) var
-
-newSATName :: SatM Name
-newSATName = SatM $ \us env ->
-                     (mkSystemVarName (uniqFromSupply us) (fsLit "$sat"), env)
-
-getArgLists :: CoreExpr -> ([Staticness Type], [Staticness Id])
-getArgLists expr
-  = let
-    (tvs, lambda_bounds, _) = collectTyAndValBinders expr
-    in
-    ([ Static (mkTyVarTy tv) | tv <- tvs ],
-     [ Static v              | v <- lambda_bounds ])
+returnSAT x = SatM $ \_ -> x
hunk ./compiler/simplCore/SAT.lhs 279
+getUniqs :: SatM [Unique]
+getUniqs = SatM $ \us -> uniqsFromSupply us
hunk ./compiler/simplCore/SAT.lhs 312
+Note [Binder type capture]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We have to contrive to ignore the static type arguments applied to a shadowing
+local body. If we don't we get something like this:
+
+[Exported]
+[Arity 3]
+GHC.Base.until =
+  \ (@ a_aiK)
+    (p_a6T :: a_aiK -> GHC.Bool.Bool)
+    (f_a6V :: a_aiK -> a_aiK)
+    (x_a6X :: a_aiK) ->
+    letrec {
+      sat_worker_s1aU :: a_aiK -> a_aiK
+      []
+      sat_worker_s1aU =
+        \ (x_a6X :: a_aiK) ->
+          let {
+            sat_shadow_r17 :: forall a_a3O.
+                              (a_a3O -> GHC.Bool.Bool) -> (a_a3O -> a_a3O) -> a_a3O -> a_a3O
+            []
+            sat_shadow_r17 =
+              \ (@ a_aiK)
+                (p_a6T :: a_aiK -> GHC.Bool.Bool)
+                (f_a6V :: a_aiK -> a_aiK)
+                (x_a6X :: a_aiK) ->
+                sat_worker_s1aU x_a6X } in
+          case p_a6T x_a6X of wild_X3y [ALWAYS Dead Nothing] {
+            GHC.Bool.False -> GHC.Base.until @ a_aiK p_a6T f_a6V (f_a6V x_a6X);
+            GHC.Bool.True -> x_a6X
+          }; } in
+    sat_worker_s1aU x_a6X
+    
+Where sat_shadow has captured the type variables of x_a6X etc as it has a a_aiK 
+type argument. This is bad because it means the application sat_worker_s1aU x_a6X
+is not well typed.
+
+We solve this by manufacturing a phony type variable that replaces a_aiK in the
+sat_shadow_r17 binding but NOT obviously in the top level binding. This phony
+manufacturing is applied to all static type variables.
+
hunk ./compiler/simplCore/SAT.lhs 367
-saTransform :: Id -> CoreExpr -> SatM CoreBind
-saTransform binder rhs = do
-    r <- getSATInfo binder
-    case r of
-      Just (_, args) | should_transform args
-        -> do
-            -- In order to get strictness information on this new binder
-            -- we need to make sure this stage happens >before< the analysis
-            sat_name <- newSATName
-            let new_rhs = mkNewRhs sat_name args
-            return (NonRec binder new_rhs)
-      _ -> return (Rec [(binder, rhs)])
-  where
-    should_transform args
-      = staticArgsLength > 1                              -- THIS IS THE DECISION POINT
-      where staticArgsLength = length (filter isStatic args)
+saTransformMaybe :: [Unique] -> Id -> Maybe SATInfo -> [Id] -> CoreExpr -> CoreBind
+saTransformMaybe uniques binder maybe_arg_staticness rhs_binders rhs_body =
+    case maybe_arg_staticness of
+        Just arg_staticness -> if shouldTransform arg_staticness
+                               then saTransform uniques binder arg_staticness rhs_binders rhs_body
+                               else untransformed_rhs
+        Nothing -> untransformed_rhs
+  where shouldTransform staticness = (length (filter isStaticValue staticness)) > 1 -- THIS IS THE DECISION POINT
+        untransformed_rhs = Rec [(binder, mkLams rhs_binders rhs_body)]
hunk ./compiler/simplCore/SAT.lhs 377
-    (rhs_binders, rhs_body) = collectBinders rhs
-    rhs_val_binders = filter isId rhs_binders
hunk ./compiler/simplCore/SAT.lhs 378
-    mkNewRhs name' args
-      = mkLams rhs_binders $
-                Let (Rec [(bndr', rec_body)]) {-in-} local_body
+saTransform :: [Unique] -> Id -> SATInfo -> [Id] -> CoreExpr -> CoreBind
+saTransform (rec_body_name_uniq:uniques) binder arg_staticness rhs_binders rhs_body = NonRec binder new_rhs
+  where
+    -- Running example: foldr
+    -- foldr \alpha \beta c n xs = e, for some e
+    -- arg_staticness = [Static TypeApp, Static TypeApp, Static VarApp, Static VarApp, NonStatic]
+    -- rhs_binders = [\alpha, \beta, c, n, xs]
+    -- rhs_body = e
+    
+    non_static_args, rhs_binders_without_type_capture :: [Var]
+    (non_static_args, rhs_binders_without_type_capture) = processBinders uniques arg_staticness rhs_binders
hunk ./compiler/simplCore/SAT.lhs 390
-        non_static_args :: [Var]
-        non_static_args = get_nsa args rhs_val_binders
-          where
-            get_nsa :: [Staticness a] -> [a] -> [a]
-            get_nsa [] _ = []
-            get_nsa _ [] = []
-            get_nsa (NotStatic:args) (v:as) = v:get_nsa args as
-            get_nsa (_:args)         (_:as) =   get_nsa args as
+        processBinders :: [Unique] -> [Staticness App] -> [Var] -> ([Var], [Var])
+        processBinders _ [] vs = (vs, vs) -- Less arguments were applied we have at the top level: assume the remainder are non-static
+        processBinders _ _  [] = ([], []) -- More static arguments were applied than are immediately visible at the top level
+        processBinders (u:us) (arg:args) (v:vs) = 
+            let (nsa_rest, rhswtc_rest) = processBinders us args vs
+            in case arg of
+                NotStatic -> (v : nsa_rest, v : rhswtc_rest)
+                Static (TypeApp _) -> (nsa_rest, (mkTyVar (tyVarName v) (tyVarKind v) `setTyVarUnique` u) : rhswtc_rest)
+                Static (VarApp _)  -> (nsa_rest, v : rhswtc_rest)
+        processBinders [] _ _ = panic "processBinders"
+    -- non_static_args = [xs]
+    -- rhs_binders_without_type_capture = [\alpha', \beta', c, n, xs]
hunk ./compiler/simplCore/SAT.lhs 403
-        bndr' = mkLocalId name' (exprType rec_body)
+    rec_body_bndr = mkLocalId (mkSystemVarName rec_body_name_uniq (fsLit "sat_worker")) (exprType rec_body)
+    -- rec_body_bndr = sat_worker
+    
+    local_body = mkVarApps (Var rec_body_bndr) non_static_args
+    -- local_body = sat_worker xs
hunk ./compiler/simplCore/SAT.lhs 409
-        rec_body = mkLams non_static_args $
-                    Let (NonRec shadow_binder nonrec_rhs) rhs_body
-        nonrec_rhs = mkLams rhs_binders local_body
-        local_body = mkVarApps (Var bndr') non_static_args
+    -- See Note [Binder type capture]
+    nonrec_rhs = mkLams rhs_binders_without_type_capture local_body
+    -- nonrec_rhs = \alpha' beta' c n xs -> sat_worker xs
hunk ./compiler/simplCore/SAT.lhs 413
+    -- See Note [Shadow binding]
+    shadow_bndr = mkSysLocal (fsLit "sat_shadow") (getUnique binder) (exprType nonrec_rhs)
+    -- shadow_bndr = sat_shadow
hunk ./compiler/simplCore/SAT.lhs 417
-        -- See Note [Shadow binding]
-        shadow_binder = mkSysLocal (fsLit "sat") (getUnique binder) (idType binder)
+    rec_body = mkLams non_static_args $
+                Let (NonRec shadow_bndr nonrec_rhs) rhs_body
+    -- rec_body = \xs -> let sat_shadow = \alpha' beta' c n xs -> sat_worker xs in e
+    
+    new_rhs = mkLams rhs_binders $ Let (Rec [(rec_body_bndr, rec_body)]) local_body
+    -- new_rhs = \alpha beta c n xs -> 
+    --              let sat_worker = (\xs -> let sat_shadow = \alpha' beta' c n xs -> sat_worker xs 
+    --                                 in e) 
+    --              in sat_worker xs
+saTransform [] _ _ _ _ = panic "saTransform"
hunk ./compiler/simplCore/SAT.lhs 428
-isStatic :: Staticness a -> Bool
-isStatic NotStatic = False
-isStatic _         = True
+isStaticValue :: Staticness App -> Bool
+isStaticValue (Static (VarApp _)) = True
+isStaticValue _                   = False
}

Context:

[Fix warnings in TcTyClsDecls
Ian Lynagh <igloo@earth.li>**20080606213239] 
[Fix warnings in TcHsType
Ian Lynagh <igloo@earth.li>**20080606204854] 
[Fix warnings in TcSimplify
Ian Lynagh <igloo@earth.li>**20080606202435] 
[Fix warnings in TcRules
Ian Lynagh <igloo@earth.li>**20080606200800] 
[Fix warnings in TcInstDcls
Ian Lynagh <igloo@earth.li>**20080606200534] 
[Fix warnings in TcMType
Ian Lynagh <igloo@earth.li>**20080606194931] 
[Fix warnings in TcForeign
Ian Lynagh <igloo@earth.li>**20080606192610] 
[Fix warnings in TcClassDcl
Ian Lynagh <igloo@earth.li>**20080606191413] 
[Fix a bug in eqPatType
Ian Lynagh <igloo@earth.li>**20080606184631
 One of the conditions we were checking was
     t2 `eqPatLType` t2
 rather than
     t1 `eqPatLType` t2
] 
[Show whether DEBUG is on in ghc --info
Ian Lynagh <igloo@earth.li>**20080606184415] 
[Use -fno-toplevel-reorder with gcc >= 4.2 on sparc-solaris; fixes trac #2312
Ian Lynagh <igloo@earth.li>**20080606133817] 
[Teach configure about amd64/NetBSD; fixes trac #2348
Ian Lynagh <igloo@earth.li>**20080606130955] 
[Enable the mangler for netbsd/amd64; fixes trac #2347
Ian Lynagh <igloo@earth.li>**20080606130706] 
[Improve documentation for standalone deriving
simonpj@microsoft.com**20080606122459] 
[Fix Trac #2334: validity checking for type families
simonpj@microsoft.com**20080606121730
 
 When we deal with a family-instance declaration (TcTyClsDecls.tcFamInstDecl)
 we must check the TyCon for validity; for example, that a newtype has exactly
 one field.  That is done all-at-once for normal declarations, and had been
 forgotten altogether for families.
 
 I also refactored the interface to tcFamInstDecl1 slightly.
 
 
 A slightly separate matter: if there's an error in family instances
 (e.g. overlap) we get a confusing error message cascade if we attempt to
 deal with 'deriving' clauses too; this patch bales out earlier in that case.
 
 
 Another slightly separate matter: standalone deriving for family 
 instances can legitimately have more specific types, just like normal
 data decls. For example
    
    data instance F [a] = ...
    deriving instance (Eq a, Eq b) => Eq (F [(a,b)])
 
 So tcLookupFamInstExact can a bit more forgiving than it was.
  
 
] 
[Vital follow-up to fix of Trac #2045
simonpj@microsoft.com**20080605165434
 
 Sorry -- my 'validate' didn't work right and I missed a trick.
 This patch must accompany
 
  * Fix Trac #2045: use big-tuple machiney for implication constraints
 
 
] 
[Fix Trac #2045: use big-tuple machiney for implication constraints
simonpj@microsoft.com**20080605145617] 
[Comments only
simonpj@microsoft.com**20080605134743] 
[Desugar multiple polymorphic bindings more intelligently
simonpj@microsoft.com**20080605124423
 
 Occasionally people write very large recursive groups of definitions. 
 In general we desugar these to a single definition that binds tuple,
 plus lots of tuple selectors.  But that code has quadratic size, which
 can be bad.
 
 This patch adds a new case to the desugaring of bindings, for the
 situation where there are lots of polymorphic variables, but no
 dictionaries.  (Dictionaries force us into the general case.)
 
 See Note [Abstracting over tyvars only].  
 
 The extra behaviour can be disabled with the (static) flag
 
        -fno-ds-multi-tyvar
 
 in case we want to experiment with switching it on or off.  There is
 essentially-zero effect on the nofib suite though.
 
 I was provoked into doing this by Trac #1136.  In fact I'm not sure
 it's the real cause of the problem there, but it's a good idea anyway.
 
] 
[Add non-recursive let-bindings for types
simonpj@microsoft.com**20080605123612
 
 This patch adds to Core the ability to say
        let a = Int in <body>
 where 'a' is a type variable.  That is: a type-let.
 See Note [Type let] in CoreSyn.
 
 * The binding is always non-recursive
 * The simplifier immediately eliminates it by substitution 
 
 So in effect a type-let is just a delayed substitution.  This is convenient
 in a couple of places in the desugarer, one existing (see the call to
 CoreTyn.mkTyBind in DsUtils), and one that's in the next upcoming patch.
 
 The first use in the desugarer was previously encoded as
        (/\a. <body>) Int
 rather that eagerly substituting, but that was horrid because Core Lint
 had do "know" that a=Int inside <body> else it would bleat.  Expressing
 it directly as a 'let' seems much nicer.
 
 
] 
[Fix Trac #2339: reify (mkName "X")
simonpj@microsoft.com**20080604150207] 
[Fix Trac #2310: result type signatures are not supported any more
simonpj@microsoft.com**20080604145115
 
 We have not supported "result type signatures" for some time, but 
 using one in the wrong way caused a crash.  This patch tidies it up.
 
] 
[Sort modules and packages in debug print (reduce test wobbles)
simonpj@microsoft.com**20080604144049
 
 This affects only the debug print TcRnDriver.pprTcGblEnv, and eliminates
 test-suite wobbling (affected me for tc168, tc231) 
 
] 
[Fix #2334: tyvar binders can have Names inside (equality predicates)
Simon Marlow <marlowsd@gmail.com>**20080604113002] 
[fix pointer tagging bug in removeIndirections (fixes stableptr003)
Simon Marlow <marlowsd@gmail.com>**20080604105458] 
[Fix unreg build
Simon Marlow <marlowsd@gmail.com>**20080604093653] 
[tiny tweak to the stack squeezing heuristic (fixes cg060)
Simon Marlow <marlowsd@gmail.com>**20080604091244] 
[MacOS installer: don't quote XCODE_EXTRA_CONFIGURE_ARGS
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080604021321] 
[MacOS installer: terminate build on intermediate failure
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080604020155] 
[Fix Trac #2331 (error message suggestion)
simonpj@microsoft.com**20080603134645] 
[Improve documentation of RULES
simonpj@microsoft.com**20080530155137] 
[Improve documentation for INLINE pragma
simonpj@microsoft.com**20080530133307] 
[add debugDumpTcRn and use it for some debugging output
Simon Marlow <marlowsd@gmail.com>**20080603112030] 
[Turn "NOTE: Simplifier still going..." message into a WARN()
Simon Marlow <marlowsd@gmail.com>**20080603105431] 
[remove the "expanding to size" messages
Simon Marlow <marlowsd@gmail.com>**20080603094546] 
[New flag: -dno-debug-output
Simon Marlow <marlowsd@gmail.com>**20080603082924
 From the docs:
    <para>Suppress any unsolicited debugging output.  When GHC
      has been built with the <literal>DEBUG</literal> option it
      occasionally emits debug output of interest to developers.
      The extra output can confuse the testing framework and
      cause bogus test failures, so this flag is provided to
      turn it off.</para>
] 
[-no-link-chk has been a no-op since at least 6.0; remove it
Simon Marlow <marlowsd@gmail.com>**20080603082041] 
[-no-link-chk is a relic
Simon Marlow <marlowsd@gmail.com>**20080603081904] 
[Shorten debug messages
simonpj@microsoft.com**20080603121208] 
[Fix minor layout issue (whitespace only)
simonpj@microsoft.com**20080602130611] 
[MacOS installer: clean up Xcode project spec
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080602070705] 
[Fix validate: -Werror bug in patch "Replacing copyins and copyouts..."
Simon Marlow <marlowsd@gmail.com>**20080602144945] 
[FIX #2231: add missing stack check when applying a PAP
Simon Marlow <marlowsd@gmail.com>**20080602143726
 This program makes a PAP with 203 arguments :-)
] 
[-fforce-recomp should be unnecessary for Main.hs in stage[23] now
Simon Marlow <marlowsd@gmail.com>**20080602133801] 
[Missing import in C-- parser
dias@eecs.harvard.edu**20080602103156] 
[TAG 2008-06-01
Ian Lynagh <igloo@earth.li>**20080601155241] 
[Fix a bug to do with recursive modules in one-shot mode
Simon Marlow <marlowsd@gmail.com>**20080530145349
 The problem was that when loading interface files in checkOldIface, we
 were not passing the If monad the mutable variable for use when
 looking up entities in the *current* module, with the result that the
 knots wouldn't be tied properly, and some instances of TyCons would
 be incorrectly abstract.
 
 This bug has subtle effects: for example, recompiling a module without
 making any changes might lead to a slightly different result (noticed
 due to the new interface-file fingerprints).  The bug doesn't lead to
 any direct failures that we're aware of.
] 
[Replacing copyins and copyouts with data-movement instructions
dias@eecs.harvard.edu**20080529160545
 
 o Moved BlockId stuff to a new file to avoid module recursion
 o Defined stack areas for parameter-passing locations and spill slots
 o Part way through replacing copy in and copy out nodes
   - added movement instructions for stack pointer
   - added movement instructions for call and return parameters
     (but not with the proper calling conventions)
 o Inserting spills and reloads for proc points is now procpoint-aware
   (it was relying on the presence of a CopyIn node as a proxy for
    procpoint knowledge)
 o Changed ZipDataflow to expect AGraphs (instead of being polymorphic in
    the type of graph)
] 
[disable SAT for now (see #2321)
Simon Marlow <marlowsd@gmail.com>**20080530112043] 
[Add dph packages to build system
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080530050340] 
[PackageMaker target depends on deployment target
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080529041820] 
[hs_add_root: use use rts_lock()/rts_unlock() for a bit of extra safety
Simon Marlow <marlowsd@gmail.com>**20080529111023] 
[Make it less fatal to not call ioManagerStart()
Simon Marlow <marlowsd@gmail.com>**20080529110957
 For clients that forget to do hs_add_root()
] 
[FIX BUILD with GHC 6.4.x
Simon Marlow <marlowsd@gmail.com>**20080529132544] 
[FIX #1970: ghci -hide-all-packages should work
Simon Marlow <marlowsd@gmail.com>**20080528154528] 
[Cmm back end upgrades
dias@eecs.harvard.edu**20080529094827
 
 Several changes in this patch, partially bug fixes, partially new code:
 o bug fixes in ZipDataflow
    - added some checks to verify that facts converge
    - removed some erroneous checks of convergence on entry nodes
    - added some missing applications of transfer functions
 o changed dataflow clients to use ZipDataflow, making ZipDataflow0 obsolete
 o eliminated DFA monad (no need for separate analysis and rewriting monads with ZipDataflow)
 o started stack layout changes
    - no longer generating CopyIn and CopyOut nodes (not yet fully expunged though)
    - still not using proper calling conventions
 o simple new optimizations:
    - common block elimination
       -- have not yet tried to move the Adams opt out of CmmProcPointZ
    - block concatenation
 o piped optimization fuel up to the HscEnv
    - can be limited by a command-line flag
    - not tested, and probably not yet properly used by clients
 o added unique supply to FuelMonad, also lifted unique supply to DFMonad
] 
[make framework-pkg needs to cope with missing DSTROOT
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080527113007] 
[Use MD5 checksums for recompilation checking (fixes #1372, #1959)
Simon Marlow <marlowsd@gmail.com>**20080528125258
 
 This is a much more robust way to do recompilation checking.  The idea
 is to create a fingerprint of the ABI of an interface, and track
 dependencies by recording the fingerprints of ABIs that a module
 depends on.  If any of those ABIs have changed, then we need to
 recompile.
 
 In bug #1372 we weren't recording dependencies on package modules,
 this patch fixes that by recording fingerprints of package modules
 that we depend on.  Within a package there is still fine-grained
 recompilation avoidance as before.
 
 We currently use MD5 for fingerprints, being a good compromise between
 efficiency and security.  We're not worried about attackers, but we
 are worried about accidental collisions.
 
 All the MD5 sums do make interface files a bit bigger, but compile
 times on the whole are about the same as before.  Recompilation
 avoidance should be a bit more accurate than in 6.8.2 due to fixing
 #1959, especially when using -O.
] 
[don't make -ddump-if-trace imply -no-recomp
Simon Marlow <marlowsd@gmail.com>**20080523140719] 
[clarify that unsafeCoerce# :: Float# -> Int# is not safe (see #2209)
Simon Marlow <marlowsd@gmail.com>**20080527090244] 
[when linking, ignore unknown .reloc section that appeared in gcc 3.4.5(?)
dias@eecs.harvard.edu**20080528121450] 
[TAG 2008-05-28
Ian Lynagh <igloo@earth.li>**20080528003600] 
[Simplify specifying that some libraries need to use the build.* rules
Ian Lynagh <igloo@earth.li>**20080526160218
 Now you just add them to SUBDIRS_BUILD instead of SUBDIRS.
] 
[Cope with libraries in libraries/foo/bar rather than just libraries/foo
Ian Lynagh <igloo@earth.li>**20080526135612
 You need to use the build.* rules rather than the make.* rules, though.
] 
[Fix fwrite$UNIX2003 symbols when cross-compiling for Tiger
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080526073546
 - When compiling with -mmacos-deployment-target=10.4, we need 
   --no-builtin-fprintf, as the use of GCC's builtin function 
   optimisation for fprintf together with #include "PosixSource" in the 
   RTS leads to the use of fwrite$UNIX2003 (with GCC 4.0.1 on Mac OS X 
   10.5.2).
] 
[document :source command for GHCi, point to Haskell wiki
claus.reinke@talk21.com**20080501205252
 
        as discussed in this thread:
        http://www.haskell.org/pipermail/glasgow-haskell-users/2008-April/014614.html
 
] 
[Do some stack fiddling in stg_unblockAsyncExceptionszh_ret
Ian Lynagh <igloo@earth.li>**20080523032508
 This fixes a segfault in #1657
] 
[Fix warnings in TcTyDecls
Ian Lynagh <igloo@earth.li>**20080521004251] 
[Fix whitespace in TcTyDecls
Ian Lynagh <igloo@earth.li>**20080521003935] 
[Ensure runhaskell is rebuild in stage2
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080522044900] 
[Fix Trac #1061: refactor handling of default methods
simonpj@microsoft.com**20080521130028
 
 In an instance declaration, omitted methods get a definition that
 uses the default method.  We used to generate source code and feed it
 to the type checker.  But tc199 shows that is a bad idea -- see
 Note [Default methods in instances] in TcClassDcl.
 
 So this patch refactors to insteadl all us to generate the 
 *post* typechecked code directly for default methods.
 
] 
[Comment typo
simonpj@microsoft.com**20080521130016] 
[Fix Trac #2292: improve error message for lone signatures
simonpj@microsoft.com**20080520143048
 
 Refactoring reduces code and improves error messages
 
] 
[Fix Trac #2293: improve error reporting for duplicate declarations
simonpj@microsoft.com**20080520143006] 
[Tuples cannot contain unboxed types
simonpj@microsoft.com**20080515115332
 
 This bug allowed, for example
 
   f = let x = ( 1#, 'x' ) in x
 
 which is ill-typed because you can't put an unboxed value in a tuple.
 Core Lint fails on this program.
 
 The patch makes the program be rejcted up-front.
 
 
] 
[Make TcType warning-free
Ian Lynagh <igloo@earth.li>**20080520214852] 
[Teach push-all how to send as well
Ian Lynagh <igloo@earth.li>**20080517142112] 
[Make TcUnify warning-free
Ian Lynagh <igloo@earth.li>**20080519111100] 
[Fix a comment typo
Ian Lynagh <igloo@earth.li>**20080519094126] 
[Detab TcUnify
Ian Lynagh <igloo@earth.li>**20080519094056] 
[FIX #1955: confusion between .exe.hp and .hp suffixes for heap profiles
Simon Marlow <simonmar@microsoft.com>**20080519125101
 Now we use <prog>.hp and <prog>.prof consistently.
] 
[sort the output of :show packages
Simon Marlow <marlowsd@gmail.com>**20080520084221] 
[update the "perf" settings to match the default
Simon Marlow <marlowsd@gmail.com>**20080520080535] 
[use -O2 for libraries and stage2 compiler by default
Simon Marlow <marlowsd@gmail.com>**20080520080525] 
[bump GHC's maximum stack size to 64Mb (see #2002)
Simon Marlow <marlowsd@gmail.com>**20080519125333] 
[Add -Odph
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080520031913
 
 This is the optimisation level recommended when compiling DPH programs. At the
 moment, it is equivalent to -O2 -fno-method-sharing -fdicts-cheap
 -fmax-simplifier-iterations20 -fno-spec-constr-threshold.
] 
[Make -f[no-]method-sharing a dynamic flag
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080520025956
 
 We want -Odph to be a dynamic flag and that should imply -fno-method-sharing.
 This doesn't add a lot of complexity.
] 
[documentation for ZipDataflow
Norman Ramsey <nr@eecs.harvard.edu>**20080520032454] 
[Make TcBinds warning-free
Ian Lynagh <igloo@earth.li>**20080518133140] 
[Detab TcBinds
Ian Lynagh <igloo@earth.li>**20080518125606] 
[Move the register-inplace special-case stuff into the ghc-prim package
Ian Lynagh <igloo@earth.li>**20080517002224] 
[Libraries Makefile Hack for ndp
Ian Lynagh <igloo@earth.li>**20080516235818
 We use the "build" rather than "make" target
] 
[When building libraries, we need to register them if we use the "build" targets
Ian Lynagh <igloo@earth.li>**20080516235352
 We currently only use the "make" targets, which already register the package.
] 
[Add dummy LICENSE file to make Cabal go through
Tim Chevalier <chevalier@alum.wellesley.edu>**20080517025351
 
 Add a LICENSE file that just points to the GHC license.
] 
[FIX #2257: timer_settime() hangs during configure
Simon Marlow <marlowsd@gmail.com>**20080516130045
 On a 2.6.24 Linux kernel, it appears that timer_settime() for
 CLOCK_REALTIME is sometimes hanging for a random amount of time when
 given a very small interval (we were using 1ns).  Using 1ms seems to
 be fine.  Also I installed a 1-second timeout to catch hangs in the
 future.
] 
[validate fix: eliminate a warning
Simon Marlow <marlowsd@gmail.com>**20080516095947] 
[validate fix: eliminate a warning on non-Windows
Simon Marlow <marlowsd@gmail.com>**20080515142518] 
[FIX #2014: Template Haskell w/ mutually recursive modules
Simon Marlow <marlowsd@gmail.com>**20080515134515
 Try to load interfaces in getLinkDeps
] 
[Document ghc-pkg find-module, substring matching, and multi-field selection
claus.reinke@talk21.com**20080501152700
 
        Documentation and examples taken from 
        - ghc-pkg/Main.hs usageHeader
        - patch: FIX 1463 (implement 'ghc-pkg find-module')
        - patch: FIX #1839, #1463, by supporting ghc-pkg bulk queries 
                        with substring matching
 
 
] 
[Improve the treatment of 'seq' (Trac #2273)
simonpj@microsoft.com**20080516085149
 
 Trac #2273 showed a case in which 'seq' didn't cure the space leak
 it was supposed to.  This patch does two things to help
 
 a) It removes a now-redundant special case in Simplify, which
    switched off the case-binder-swap in the early stages.  This
    isn't necessary any more because FloatOut has improved since
    the Simplify code was written.  And switching off the binder-swap
    is harmful for seq.
 
 However fix (a) is a bit fragile, so I did (b) too:
 
 b) Desugar 'seq' specially.  See Note [Desugaring seq (2)] in DsUtils
    This isn't very robust either, since it's defeated by abstraction, 
    but that's not something GHC can fix; the programmer should use
    a let! instead.
 
] 
[don't rebuild PrimEnv if genprimopcode and/or primops.txt don't exist
Tim Chevalier <chevalier@alum.wellesley.edu>**20080515230405
 
 This helps if, for example, you want to build the Core tools on a machine that doesn't have a GHC build tree, and have a pre-existing copy of PrimEnv.hs.
] 
[Fix a division-by-zero when +RTS -V0 is given
Ian Lynagh <igloo@earth.li>**20080426184355
 In delayzh_fast we act as if tickInterval was 50, not 0.
] 
[Cabalize ext-core tools
Tim Chevalier <chevalier@alum.wellesley.edu>**20080514235341
 
 I cabalized the ext-core tools, so now they can be built as
 a library. The driver program has to be built separately.
 
 Also updated genprimopcode to reflect the new module hierarchy
 for the Core tools.
] 
[Remove Distribution.Compat.Char from compat again
Ian Lynagh <igloo@earth.li>**20080514125152
 Cabal now does this differently.
] 
[Fix an assertion
Ian Lynagh <igloo@earth.li>**20080426110115
 We were checking that a pointer was correctly tagged, but after we had
 untagged it.
] 
[Fix sin/cos/tan on x86; trac #2059
Ian Lynagh <igloo@earth.li>**20080503000841
 If the value is > 2^63 then we need to work out its value mod 2pi,
 and apply the operation to that instead.
] 
[FIX #1288: GHCi wasn't adding the @n suffix to stdcalls on Windows
Simon Marlow <simonmar@microsoft.com>**20080514092742] 
[FIX #2276: foreign import stdcall "&foo" doesn't work
Simon Marlow <simonmar@microsoft.com>**20080514082422
 This turned out not to be too hard, just a matter of figuring out the
 correct argument list size by peeking inside FunPtr's type argument,
 and in the C backend we have to emit an appropriate prototype for the label.
] 
[Use -fffi when compiling Cabal stuff with the bootstrapping compiler
Ian Lynagh <igloo@earth.li>**20080513211128] 
[Use zipLazy from Util in VectType, rather than defining our own lazy_zip
Ian Lynagh <igloo@earth.li>**20080513202154] 
[Add a type signature to help GHC 6.4
Ian Lynagh <igloo@earth.li>**20080513200641
 Needed in lieu of -XRelaxedPolyRec
] 
[Rewrite zipLazy to be warning-free for GHC 6.4
Ian Lynagh <igloo@earth.li>**20080513193901] 
[Add Distribution.Compat.Char to compat
Ian Lynagh <igloo@earth.li>**20080513192243] 
[Add Distribution.Compat.Exception to the compat library
Ian Lynagh <igloo@earth.li>**20080513190022] 
[Fix spelling of nonexistEnt
Ian Lynagh <igloo@earth.li>**20080513135158] 
[FIX #1641: don't add auto sccs to compiler-generated bindings
Simon Marlow <marlowsd@gmail.com>**20080513084400
 I also changed con2tag_Foo and related names to follow the standard
 practice of prefixing $ to compiler-generated names, so now we have
 $con2tag_Foo.
] 
[Fix the Windows build; the new Cabal doesn't like --prefix=/foo
Ian Lynagh <igloo@earth.li>**20080512170507] 
[Pull the configure options out into a variable in libraries/Makefile
Ian Lynagh <igloo@earth.li>**20080511203932] 
[typo in rules example. spotted by vixey@#haskell
Don Stewart <dons@galois.com>**20080512182435] 
[Fixes to via-C prototype generation (FIX BUILD on Windows)
Simon Marlow <simonmar@microsoft.com>**20080512110643
   
 Previously we declared all external labels with type StgWord[],
 because the same label might be used at different types in the same
 file, e.g. if there are multiple foreign import declarations for the
 same function.  However, we have to declare called functions with the
 right type on Windows, because this is the only way to make the
 compiler add the appropriate '@n' suffix for stdcall functions.
 
 Related to this is the reason we were getting mangler complaints
 (epilogue mangling) when compiling the RTS with -fvia-C.  The function
 barf() doesn't return, but we had lost that information by declaring
 our own prototypes, and so gcc was generating extra code after the
 call to barf().
 
 For more details see
 http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/Backends/PprC
] 
[doc tweak
Simon Marlow <marlowsd@gmail.com>**20080512104030] 
[FIX #2234: don't generate <prog>.prof unless we're going to put something in it
Simon Marlow <marlowsd@gmail.com>**20080512104020] 
[FIX #1861: floating-point constants for infinity and NaN in via-C
Simon Marlow <marlowsd@gmail.com>**20080512103847] 
[Tell the mangler how to mangle for amd64/freebsd; fixes trac #2072
Ian Lynagh <igloo@earth.li>**20080511182011] 
[Follow distPref changes in Cabal
Ian Lynagh <igloo@earth.li>**20080511144539] 
[Follow Cabal changes in ghci/Linker
Ian Lynagh <igloo@earth.li>**20080511005253] 
[Follow changes in Cabal
Ian Lynagh <igloo@earth.li>**20080510225552] 
[Remove redundant imports from Inst
Ian Lynagh <igloo@earth.li>**20080510220452] 
[Fix a warning when DEBUG is not on
Ian Lynagh <igloo@earth.li>**20080510220329] 
[Update compat for changes to Cabal
Ian Lynagh <igloo@earth.li>**20080510211901] 
[Update ghc-pkg to follow Cabal changes
Ian Lynagh <igloo@earth.li>**20080510211035] 
[Make TcGenDeriv warning-free
Ian Lynagh <igloo@earth.li>**20080506210858] 
[Make TcMatches warning-free
Ian Lynagh <igloo@earth.li>**20080506204254] 
[Make TcHsSyn warning-free
Ian Lynagh <igloo@earth.li>**20080506201829] 
[Make TcRnMonad warning-free
Ian Lynagh <igloo@earth.li>**20080506193359] 
[Make TcDefaults warning-free
Ian Lynagh <igloo@earth.li>**20080506191728] 
[Make TcArrows warning-free
Ian Lynagh <igloo@earth.li>**20080506191141] 
[TcSplice is now mostly warning-free
Ian Lynagh <igloo@earth.li>**20080506180618
 There are some unused things, but I am not sure if the intention is that
 they will be used in the future. Names implied they were related to
 splicing in patterns and types.
] 
[Make Inst warning-free
Ian Lynagh <igloo@earth.li>**20080506173842] 
[Add a panic for lookupPred EqPred
Ian Lynagh <igloo@earth.li>**20080506171749
 It's possible that returning Nothing was the right thing to do here,
 but the comment and variable name indicated that it was written for
 implicit parameters, so make it a panic for now just in case.
] 
[Make FamInst warning-free
Ian Lynagh <igloo@earth.li>**20080506171031] 
[Fix context for fwd_pure_anal to match that of forward_sol
simonpj@microsoft.com**20080507072825] 
[FIX validate: Fix warnings in new literal code
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080507035417
 
 Validate uses -Werror so the warnings broke it.
] 
[Vectorise even with -O0
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080507020055] 
[Remove ilxGen; part of trac #2243
Ian Lynagh <igloo@earth.li>**20080506104456] 
[Remove javaGen; part of trac #2243
Ian Lynagh <igloo@earth.li>**20080506104307] 
[Add a comment about why DsMeta needs the warning kludge
Ian Lynagh <igloo@earth.li>**20080506103506] 
[Fix Trac #2246; overhaul handling of overloaded literals
simonpj@microsoft.com**20080506102551
 
 The real work of fixing Trac #2246 is to use shortCutLit in
 MatchLit.dsOverLit, so that type information discovered late in the
 day by the type checker can still be exploited during desugaring.
 
 However, as usual I found myself doing some refactoring along the
 way, to tidy up the handling of overloaded literals.   The main
 change is to split HsOverLit into a record, which in turn uses
 a sum type for the three variants.  This makes the code significantly
 more modular.
 
 data HsOverLit id
   = OverLit {
        ol_val :: OverLitVal, 
        ol_rebindable :: Bool,          -- True <=> rebindable syntax
                                        -- False <=> standard syntax
        ol_witness :: SyntaxExpr id,    -- Note [Overloaded literal witnesses]
        ol_type :: PostTcType }
 
 data OverLitVal
   = HsIntegral   !Integer      -- Integer-looking literals;
   | HsFractional !Rational     -- Frac-looking literals
   | HsIsString   !FastString   -- String-looking literals
 
] 
[Fix type signature to work without -XRelaxedPolyRec, and hence earlier GHCs
simonpj@microsoft.com**20080506095817] 
[Eliminate a warning for compiler/basicTypes/OccName.lhs
Thorkil Naur <naur@post11.tele.dk>**20080504191511] 
[External Core tools: add note to README about where to find documentation
Tim Chevalier <chevalier@alum.wellesley.edu>**20080505004603] 
[Some External Core doc fixes
Tim Chevalier <chevalier@alum.wellesley.edu>**20080505003955] 
[External Core tools: track new syntax for newtypes
Tim Chevalier <chevalier@alum.wellesley.edu>**20080505001050
 
 Update External Core tools to reflect new syntax for
 newtypes. (Notice that the typechecker is 90 lines shorter!)
 
 Also: improve dependency-finding, miscellaneous refactoring.
] 
[Improve External Core newtype syntax
Tim Chevalier <chevalier@alum.wellesley.edu>**20080504230233
 
 I realized that recursive newtypes no longer have to be
 distinguished in the External Core AST, because explicit coercions
 allow the typechecker to typecheck newtypes without ever 
 expanding newtypes. So, now all newtypes in External Core have
 a representation clause. O frabjous day!
 
] 
[Remove a duplicate module import in BuildTyCl
Ian Lynagh <igloo@earth.li>**20080504222023] 
[Make SimplEnv warning-free
Ian Lynagh <igloo@earth.li>**20080504213123] 
[Make SimplUtils warning-free
Ian Lynagh <igloo@earth.li>**20080504212447] 
[Remove a hack for GHC 3.03 in SimplMonad
Ian Lynagh <igloo@earth.li>**20080504205935] 
[Make SimplMonad warning-free
Ian Lynagh <igloo@earth.li>**20080504205630] 
[Make LiberateCase warning-free
Ian Lynagh <igloo@earth.li>**20080504204729] 
[Make FloatOut warning-free
Ian Lynagh <igloo@earth.li>**20080504204058] 
[Make FloatIn warning-free
Ian Lynagh <igloo@earth.li>**20080504202538] 
[Make SetLevels warning-free
Ian Lynagh <igloo@earth.li>**20080504201710] 
[Make Vectorise warning-free
Ian Lynagh <igloo@earth.li>**20080504195430] 
[Remove some dead code from VectType
Ian Lynagh <igloo@earth.li>**20080504194432] 
[Make VectType warning-free
Ian Lynagh <igloo@earth.li>**20080504194335] 
[Make IfaceEnv warning-free
Ian Lynagh <igloo@earth.li>**20080504190944] 
[Make IfaceSyn warning-free
Ian Lynagh <igloo@earth.li>**20080504190710] 
[Make IfaceType warning-free
Ian Lynagh <igloo@earth.li>**20080504183529] 
[Make BuildTyCl warning-free
Ian Lynagh <igloo@earth.li>**20080504182336] 
[Make BinIface warning-free
Ian Lynagh <igloo@earth.li>**20080504182031] 
[Make LoadIface warning-free
Ian Lynagh <igloo@earth.li>**20080504180847] 
[Make MkIface warning-free
Ian Lynagh <igloo@earth.li>**20080504174952] 
[Make TcIface warning-free
Ian Lynagh <igloo@earth.li>**20080504172906] 
[Make StgLint warning-free
Ian Lynagh <igloo@earth.li>**20080504151343] 
[Make CoreToStg warning-free
Ian Lynagh <igloo@earth.li>**20080504145432] 
[Make DsArrows warning-free
Ian Lynagh <igloo@earth.li>**20080504140443] 
[Make DsCCall warning-free
Ian Lynagh <igloo@earth.li>**20080504132635] 
[Make DsMeta almost warning-free
Ian Lynagh <igloo@earth.li>**20080504125742
 GHC claims that OccName is unused, but it is wrong.
] 
[Make MatchLit warning-free
Ian Lynagh <igloo@earth.li>**20080504114848] 
[Add an Outputable EquationInfo instance
Ian Lynagh <igloo@earth.li>**20080504114827] 
[Whitespace only (TcInstDcls)
Ian Lynagh <igloo@earth.li>**20080504111101] 
[Fix the stage 1 build
Ian Lynagh <igloo@earth.li>**20080504011733] 
[Remove unused function mapInScopeSet
Ian Lynagh <igloo@earth.li>**20080503191450] 
[Make part of the parser a bit stricter
Ian Lynagh <igloo@earth.li>**20080502225717] 
[Fix some space-wasting in the Parser
Ian Lynagh <igloo@earth.li>**20080502225645
 (fst x, snd x) => x
] 
[Make ByteCodeGen warning-free
Ian Lynagh <igloo@earth.li>**20080504002527] 
[Tiny code tweak in the definition of io in GhciMonad; no semantic change
Ian Lynagh <igloo@earth.li>**20080503235211] 
[Make GhciMonad warning-free
Ian Lynagh <igloo@earth.li>**20080503235135] 
[Tiny code recatoring in GhciTags
Ian Lynagh <igloo@earth.li>**20080503234539] 
[Make GhciTags warning-free
Ian Lynagh <igloo@earth.li>**20080503234441] 
[Make ObjLink warning-free
Ian Lynagh <igloo@earth.li>**20080503233418] 
[Remove a hack from a time when ghc couldn't do seq
Ian Lynagh <igloo@earth.li>**20080503232832] 
[Make RnExpr warning-free
Ian Lynagh <igloo@earth.li>**20080503232704] 
[Make RnEnv warning-free
Ian Lynagh <igloo@earth.li>**20080503223430] 
[Fix warnings in RnNames
Ian Lynagh <igloo@earth.li>**20080503221512] 
[Make RnBinds warning-free
Ian Lynagh <igloo@earth.li>**20080503213149] 
[Change a mappM to mapM_
Ian Lynagh <igloo@earth.li>**20080503203354] 
[Make RnPat warning-free
Ian Lynagh <igloo@earth.li>**20080503203300] 
[Make RnHsDoc warning-free
Ian Lynagh <igloo@earth.li>**20080503201343] 
[Make RnSource warning-free
Ian Lynagh <igloo@earth.li>**20080503200932] 
[Make RnHsSyn warning-free
Ian Lynagh <igloo@earth.li>**20080503170649] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080503170053] 
[Vectorise polymorphic let bindings
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080504054006] 
[Improve syntax for primitive coercions in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080504024304
 
 Add new syntax in External Core for primitive coercions (trans,
 sym, etc.) rather than wiring their names into the ext-core
 parser.
] 
[Fix External Core interpreter
Tim Chevalier <chevalier@alum.wellesley.edu>**20080503231044
 
 The External Core interpreter works (in a limited sense).
 For details, see the README.
 
 This means we now have a marginally functioning set of
 External Core tools.
 
 The other exciting change is that the test driver (Driver.hs)
 now computes module dependencies automatically instead of
 having a wired-in list of library modules.
] 
[replace hints with kinds in parser as well
Norman Ramsey <nr@eecs.harvard.edu>**20080503224720] 
[replace Cmm 'hint' with 'kind'
Norman Ramsey <nr@eecs.harvard.edu>**20080503224514
 C-- no longer has 'hints'; to guide parameter passing, it
 has 'kinds'.  Renamed type constructor, data constructor, and record
 fields accordingly
] 
[new version of ZipDataflow
Norman Ramsey <nr@eecs.harvard.edu>**20080503224208
 This version combines forward/backard into a type class
 (actually two classes) of analysis and transformation.
 These type classes will always be expanded away at the client,
 so SLPJ may wonder why they exist: it is because the interface
 to this module is already very broad, and by overloading the functions 
 for forward and backward problems, we cut the cognitive load on the
 clients in half.
] 
[minor changes to Cmm left over from September 2007
Norman Ramsey <nr@eecs.harvard.edu>**20080503223452
 Nothing too deep here; primarily tinking with prettyprinting
 and names.  Also eliminated some warnings.  This patch covers
 most (but not all) of the code NR changed at the very end
 of September 2007, just before ICFP hit...
] 
[Make darcs-all act on all repos in libraries/, not just boot/extra libs
Ian Lynagh <igloo@earth.li>**20080502174753] 
[When validating, configure with "--prefix=`pwd`/inst"
Ian Lynagh <igloo@earth.li>**20080502155649
 This means a validate build can be installed locally.
 `pwd`/inst probably won't give a useful value on all platforms (in
 particular there are probably some Windows configurations it doesn't
 work for), but I don't think it will ever make the build fail.
] 
[Improve the unboxed types documentation
Ian Lynagh <igloo@earth.li>**20080430152508
 Mainly adding descriptions of unboxed literals,
] 
[sumP on doubles and int 
keller@cse.unsw.edu.au**20080502031905] 
[Fixed vect decl for sumP, enumfromToP
keller@cse.unsw.edu.au**20080501011824] 
[Missing .0 on float constant.
Don Stewart <dons@galois.com>**20080501000517] 
[Replace C99 exp2f(32) call in __2Int_encodeDouble
Don Stewart <dons@galois.com>**20080430214827
 with constant 4294967296.
 
 exp2f is a C99-ism not availabl everywhere. Replace it
 with its result. Helps building on OpenBSD>
 
] 
[Use panic rather than error in RegLiveness
Ian Lynagh <igloo@earth.li>**20080430131349] 
[Update an error message
Ian Lynagh <igloo@earth.li>**20080430131317
 error "RegisterAlloc.livenessSCCs" -> error "RegLiveness.livenessSCCs"
] 
[Update a panic message
Ian Lynagh <igloo@earth.li>**20080430131021
 It was (panic "RegisterAlloc.joinToTargets"), but had since moved to
 RegAllocLinear.makeRegMovementGraph.
] 
[Remove BitSet, FieldLabel, RegisterAlloc from compiler/package.conf.in
Ian Lynagh <igloo@earth.li>**20080430130251
 The modules no longer exist. Spotted by Marc Weber.
] 
[Improve documentation of RULES pragmas
simonpj@microsoft.com**20080430082431] 
[change topHandlerFastExit to topHandler, so the terminal state gets restored (#2228)
Simon Marlow <simonmar@microsoft.com>**20080429222442] 
[don't turn off stdin/stdout buffering after loading a module with ghc -e (#2228)
Simon Marlow <simonmar@microsoft.com>**20080429222409] 
[FIX #1933: use a better test for timer_create()
Simon Marlow <simonmar@microsoft.com>**20080429212945] 
[Fix Trac #1969: perfomance bug in the specialiser
simonpj@microsoft.com**20080428155711
 
 The specialiser was using a rather brain-dead representation for
 UsageDetails, with much converting from lists to finite maps and
 back.  This patch does some significant refactoring.  It doesn't
 change the representation altogether, but it does eliminate the
 to-and-fro nonsense.
 
 It validates OK, but it's always possible that I have inadvertently
 lost specialisation somewhere, so keep an eye out for any run-time
 performance regressions.
 
 Oh, and Specialise is now warning-free too.
 
] 
[Fix Trac #2238: do not use newtype for a class with equality predicates
simonpj@microsoft.com**20080428134730
 
 See Note [Class newtypes and equality predicates] in this module.
 
] 
[Add :list to ghci's :? help; fixes trac #2217
Ian Lynagh <igloo@earth.li>**20080427190049] 
[Fix an error if an SCC name contains a space; fixes trac #2071
Ian Lynagh <igloo@earth.li>**20080427114808] 
[Fix build on PPC: Add some missing parentheses
Ian Lynagh <igloo@earth.li>**20080427103545] 
[Refactor some code a bit, and improve an error
Ian Lynagh <igloo@earth.li>**20080426011634
 The "magic number mismatch: old/corrupt interface file?" error now tells
 us what we got, and what we expected.
] 
[Whitespace changes only
Ian Lynagh <igloo@earth.li>**20080426010908] 
[Fix the ticky ticky build
Ian Lynagh <igloo@earth.li>**20080425140434
 Include TickyCounters.h in Stg.h if we are doing Ticky Ticky.
] 
[Fix a couple of format strings in Ticky.c
Ian Lynagh <igloo@earth.li>**20080425134725] 
[Comment out some unused code in Ticky.c
Ian Lynagh <igloo@earth.li>**20080425134307] 
[Spelling fixes in glasgow_exts.xml
Samuel Bronson <naesten@gmail.com>**20080415232626
 Also adds a <para></para> element and replaces an occurance of SGML
 with XML...
] 
[Vectorisation of: enumFromTo, div, intSqrt
keller@cse.unsw.edu.au**20080425072421] 
[Fix int64ToInteger 0xFFFFFFFF00000000 on 32bit machine; trac #2223
Ian Lynagh <igloo@earth.li>**20080424131526
 Patch from Mike Gunter.
] 
[Add 123## literals for Word#
Ian Lynagh <igloo@earth.li>**20080423161115] 
[Whitespace changes only
Ian Lynagh <igloo@earth.li>**20080423143553] 
[Added support for vectorising emptyP, squareRoot, combineP
keller@cse.unsw.edu.au**20080424020025] 
[Add back an erroneously removed #include "HsVersions.h"
Ian Lynagh <igloo@earth.li>**20080423110930] 
[Include HsVersions.h where necessary
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080423042820] 
[Make a panic slightly more helpful
Ian Lynagh <igloo@earth.li>**20080422164916] 
[Fix build
Ian Lynagh <igloo@earth.li>**20080422133838] 
[Fix build
Ian Lynagh <igloo@earth.li>**20080422124919] 
[(F)SLIT -> (f)sLit in SimplUtils
Ian Lynagh <igloo@earth.li>**20080422124908] 
[(F)SLIT -> (f)sLit in HsBinds
Ian Lynagh <igloo@earth.li>**20080422122319] 
[(F)SLIT -> (f)sLit in StaticFlags
Ian Lynagh <igloo@earth.li>**20080422122226] 
[Build fixes
Ian Lynagh <igloo@earth.li>**20080422115500] 
[Change the last few (F)SLIT's into (f)sLit's
Ian Lynagh <igloo@earth.li>**20080422114713] 
[FSLIT -> fsLit in PrelNames
Ian Lynagh <igloo@earth.li>**20080422113907] 
[Fix warnings in PrelNames
Ian Lynagh <igloo@earth.li>**20080422113817] 
[(F)SLIT -> (f)sLit in CmmParse
Ian Lynagh <igloo@earth.li>**20080422110857] 
[PrelRules is now warning free
Ian Lynagh <igloo@earth.li>**20080413124325] 
[Remove a warning
Ian Lynagh <igloo@earth.li>**20080413103120] 
[PrelInfo is now warning-free
Ian Lynagh <igloo@earth.li>**20080413102906] 
[TysPrim is now warning-free
Ian Lynagh <igloo@earth.li>**20080413101757] 
[TysWiredIn is now warning-free
Ian Lynagh <igloo@earth.li>**20080413094012] 
[(F)SLIT -> (f)sLit in TcSplice
Ian Lynagh <igloo@earth.li>**20080412180126] 
[(F)SLIT -> (f)sLit in Convert
Ian Lynagh <igloo@earth.li>**20080412180037] 
[(F)SLIT -> (f)sLit in InteractiveUI
Ian Lynagh <igloo@earth.li>**20080412180018] 
[(F)SLIT -> (f)sLit in InteractiveEval
Ian Lynagh <igloo@earth.li>**20080412175850] 
[(F)SLIT -> (f)sLit in RtClosureInspect
Ian Lynagh <igloo@earth.li>**20080412175734] 
[(F)SLIT -> (f)sLit in Linker
Ian Lynagh <igloo@earth.li>**20080412175700] 
[(F)SLIT -> (f)sLit in ByteCodeGen
Ian Lynagh <igloo@earth.li>**20080412175456] 
[(F)SLIT -> (f)sLit in DsMeta
Ian Lynagh <igloo@earth.li>**20080412175407] 
[(F)SLIT -> (f)sLit in PprTyThing
Ian Lynagh <igloo@earth.li>**20080412163811] 
[(F)SLIT -> (f)sLit in DriverMkDepend
Ian Lynagh <igloo@earth.li>**20080412163724] 
[(F)SLIT -> (f)sLit in GHC
Ian Lynagh <igloo@earth.li>**20080412163604] 
[(F)SLIT -> (f)sLit in DriverPipeline
Ian Lynagh <igloo@earth.li>**20080412163406] 
[(F)SLIT -> (f)sLit in HscMain
Ian Lynagh <igloo@earth.li>**20080412163320] 
[(F)SLIT -> (f)sLit in TcRnDriver
Ian Lynagh <igloo@earth.li>**20080412162930] 
[(F)SLIT -> (f)sLit in TcDefaults
Ian Lynagh <igloo@earth.li>**20080412162824] 
[(F)SLIT -> (f)sLit in TcRules
Ian Lynagh <igloo@earth.li>**20080412162705] 
[(F)SLIT -> (f)sLit in TcForeign
Ian Lynagh <igloo@earth.li>**20080412162632] 
[(F)SLIT -> (f)sLit in TcExpr
Ian Lynagh <igloo@earth.li>**20080412162533] 
[(F)SLIT -> (f)sLit in TcArrows
Ian Lynagh <igloo@earth.li>**20080412162403] 
[(F)SLIT -> (f)sLit in TcMatches
Ian Lynagh <igloo@earth.li>**20080412162314] 
[(F)SLIT -> (f)sLit in TcInstDcls
Ian Lynagh <igloo@earth.li>**20080412162152] 
[(F)SLIT -> (f)sLit in FamInst
Ian Lynagh <igloo@earth.li>**20080412162033] 
[(F)SLIT -> (f)sLit in TcDeriv
Ian Lynagh <igloo@earth.li>**20080412161958] 
[(F)SLIT -> (f)sLit in TcGenDeriv
Ian Lynagh <igloo@earth.li>**20080412161827] 
[(F)SLIT -> (f)sLit in TcTyClsDecls
Ian Lynagh <igloo@earth.li>**20080412161708] 
[(F)SLIT -> (f)sLit in TcClassDcl
Ian Lynagh <igloo@earth.li>**20080412161517] 
[(F)SLIT -> (f)sLit in RnExpr
Ian Lynagh <igloo@earth.li>**20080412161410] 
[(F)SLIT -> (f)sLit in TcBinds
Ian Lynagh <igloo@earth.li>**20080412161320] 
[(F)SLIT -> (f)sLit in TcHsType
Ian Lynagh <igloo@earth.li>**20080412161045] 
[(F)SLIT -> (f)sLit in Generics
Ian Lynagh <igloo@earth.li>**20080412160944] 
[(F)SLIT -> (f)sLit in TcSimplify
Ian Lynagh <igloo@earth.li>**20080412160715] 
[(F)SLIT -> (f)sLit in TcTyFuns
Ian Lynagh <igloo@earth.li>**20080412160559] 
[(F)SLIT -> (f)sLit in Inst
Ian Lynagh <igloo@earth.li>**20080412160453] 
[(F)SLIT -> (f)sLit in RnSource
Ian Lynagh <igloo@earth.li>**20080412160348] 
[(F)SLIT -> (f)sLit in RnBinds
Ian Lynagh <igloo@earth.li>**20080412160232] 
[(F)SLIT -> (f)sLit in RnPat
Ian Lynagh <igloo@earth.li>**20080412160138] 
[(F)SLIT -> (f)sLit in RnTypes
Ian Lynagh <igloo@earth.li>**20080412160039] 
[(F)SLIT -> (f)sLit in RnNames
Ian Lynagh <igloo@earth.li>**20080412155923] 
[(F)SLIT -> (f)sLit in RnEnv
Ian Lynagh <igloo@earth.li>**20080412155810] 
[(F)SLIT -> (f)sLit in TcEnv
Ian Lynagh <igloo@earth.li>**20080412155639] 
[(F)SLIT -> (f)sLit in CSE
Ian Lynagh <igloo@earth.li>**20080412155551] 
[(F)SLIT -> (f)sLit in Simplify
Ian Lynagh <igloo@earth.li>**20080412155517] 
[(F)SLIT -> (f)sLit in SimplEnv
Ian Lynagh <igloo@earth.li>**20080412155311] 
[(F)SLIT -> (f)sLit in FloatOut
Ian Lynagh <igloo@earth.li>**20080412155114] 
[(F)SLIT -> (f)sLit in Specialse
Ian Lynagh <igloo@earth.li>**20080412155034] 
[(F)SLIT -> (f)sLit in SpecConstr
Ian Lynagh <igloo@earth.li>**20080412154959] 
[(F)SLIT -> (f)sLit in Vectorise
Ian Lynagh <igloo@earth.li>**20080412154718] 
[(F)SLIT -> (f)sLit in VectType
Ian Lynagh <igloo@earth.li>**20080412154322] 
[(F)SLIT -> (f)sLit in VectUtils
Ian Lynagh <igloo@earth.li>**20080412154229] 
[(F)SLIT -> (f)sLit in VectMonad
Ian Lynagh <igloo@earth.li>**20080412154116] 
[(F)SLIT -> (f)sLit in VectBuiltIn
Ian Lynagh <igloo@earth.li>**20080412154002] 
[(F)SLIT -> (f)sLit in SimplMonad
Ian Lynagh <igloo@earth.li>**20080412153630] 
[(F)SLIT -> (f)sLit in CoreToStg
Ian Lynagh <igloo@earth.li>**20080412153543] 
[(F)SLIT -> (f)sLit in StgLint
Ian Lynagh <igloo@earth.li>**20080412153440] 
[(F)SLIT -> (f)sLit in Parser
Ian Lynagh <igloo@earth.li>**20080412153329] 
[(F)SLIT -> (f)sLit in RdrHsSyn
Ian Lynagh <igloo@earth.li>**20080412153052] 
[(F)SLIT -> (f)sLit in SysTools
Ian Lynagh <igloo@earth.li>**20080412152909] 
[(F)SLIT -> (f)sLit in MachCodeGen
Ian Lynagh <igloo@earth.li>**20080412152750] 
[(F)SLIT -> (f)sLit in PositionIndependentCode
Ian Lynagh <igloo@earth.li>**20080412152545] 
[(F)SLIT -> (f)sLit in RegallocLinear
Ian Lynagh <igloo@earth.li>**20080412152355] 
[(F)SLIT -> (f)sLit in RegLiveness
Ian Lynagh <igloo@earth.li>**20080412152307] 
[(F)SLIT -> (f)sLit in PprMach
Ian Lynagh <igloo@earth.li>**20080412152217] 
[(F)SLIT -> (f)sLit in Desugar
Ian Lynagh <igloo@earth.li>**20080412151250] 
[(F)SLIT -> (f)sLit in MkIface
Ian Lynagh <igloo@earth.li>**20080412151147] 
[(F)SLIT -> (f)sLit in DsForeign
Ian Lynagh <igloo@earth.li>**20080412150848] 
[(F)SLIT -> (f)sLit in Match
Ian Lynagh <igloo@earth.li>**20080412150644] 
[(F)SLIT -> (f)sLit in DsBinds
Ian Lynagh <igloo@earth.li>**20080412150510] 
[(F)SLIT -> (f)sLit in Coverage
Ian Lynagh <igloo@earth.li>**20080412150416] 
[(F)SLIT -> (f)sLit in DsUtils
Ian Lynagh <igloo@earth.li>**20080412150317] 
[(F)SLIT -> (f)sLit in DsUtils
Ian Lynagh <igloo@earth.li>**20080412150231] 
[(F)SLIT -> (f)sLit in TcHsSyn
Ian Lynagh <igloo@earth.li>**20080412145639] 
[(F)SLIT -> (f)sLit in FunDeps
Ian Lynagh <igloo@earth.li>**20080412145238] 
[(F)SLIT -> (f)sLit in DsMonad
Ian Lynagh <igloo@earth.li>**20080412145201] 
[(F)SLIT -> (f)sLit in TcIface
Ian Lynagh <igloo@earth.li>**20080412145105] 
[(F)SLIT -> (f)sLit in LoadIface
Ian Lynagh <igloo@earth.li>**20080412145018] 
[(F)SLIT -> (f)sLit in Finder
Ian Lynagh <igloo@earth.li>**20080412144812] 
[(F)SLIT -> (f)sLit in TcRnMonad
Ian Lynagh <igloo@earth.li>**20080412144557] 
[(F)SLIT -> (f)sLit in TcRnTypes
Ian Lynagh <igloo@earth.li>**20080412144504] 
[(F)SLIT -> (f)sLit in WwLib
Ian Lynagh <igloo@earth.li>**20080412144123] 
[(F)SLIT -> (f)sLit in CoreSubst
Ian Lynagh <igloo@earth.li>**20080412143851] 
[(F)SLIT -> (f)sLit in CorePrep
Ian Lynagh <igloo@earth.li>**20080412143637] 
[(F)SLIT -> (f)sLit in CgCon
Ian Lynagh <igloo@earth.li>**20080412143540] 
[(F)SLIT -> (f)sLit in HscTypes
Ian Lynagh <igloo@earth.li>**20080412143353] 
[(F)SLIT -> (f)sLit in FamInstEnv
Ian Lynagh <igloo@earth.li>**20080412141122] 
[(F)SLIT -> (f)sLit in InstEnv
Ian Lynagh <igloo@earth.li>**20080412141045] 
[(F)SLIT -> (f)sLit in CgPrimOp
Ian Lynagh <igloo@earth.li>**20080412140741] 
[(F)SLIT -> (f)sLit in PprC
Ian Lynagh <igloo@earth.li>**20080412140630] 
[(F)SLIT -> (f)sLit in CgForeignCall
Ian Lynagh <igloo@earth.li>**20080412140213] 
[(F)SLIT -> (f)sLit in CgClosure
Ian Lynagh <igloo@earth.li>**20080412140136] 
[(F)SLIT -> (f)sLit in PprCmmZ
Ian Lynagh <igloo@earth.li>**20080412135934] 
[(F)SLIT -> (f)sLit in ZipCfgCmmRep
Ian Lynagh <igloo@earth.li>**20080412135902] 
[(F)SLIT -> (f)sLit in CmmLint
Ian Lynagh <igloo@earth.li>**20080412135820] 
[(F)SLIT -> (f)sLit in CmmCPSGen
Ian Lynagh <igloo@earth.li>**20080412135728] 
[(F)SLIT -> (f)sLit in CgBindery
Ian Lynagh <igloo@earth.li>**20080412135620] 
[(F)SLIT -> (f)sLit in CgHeapery
Ian Lynagh <igloo@earth.li>**20080412135529] 
[(F)SLIT -> (f)sLit in CgTicky
Ian Lynagh <igloo@earth.li>**20080412135411] 
[(F)SLIT -> (f)sLit in CgCallConv
Ian Lynagh <igloo@earth.li>**20080412135037] 
[(F)SLIT -> (f)sLit in CgProf
Ian Lynagh <igloo@earth.li>**20080412133935] 
[(F)SLIT -> (f)sLit in PprCmm
Ian Lynagh <igloo@earth.li>**20080412133323] 
[(F)SLIT -> (f)sLit in ClosureInfo
Ian Lynagh <igloo@earth.li>**20080412133030] 
[(F)SLIT -> (f)sLit in StSyn
Ian Lynagh <igloo@earth.li>**20080412132924] 
[(F)SLIT -> (f)sLit in SMRep
Ian Lynagh <igloo@earth.li>**20080412132534] 
[(F)SLIT -> (f)sLit in MachOp
Ian Lynagh <igloo@earth.li>**20080412132430] 
[(F)SLIT -> (f)sLit in CLabel
Ian Lynagh <igloo@earth.li>**20080412132305] 
[(F)SLIT -> (f)sLit in Packages
Ian Lynagh <igloo@earth.li>**20080412132158] 
[(F)SLIT -> (f)sLit in Lexer
Ian Lynagh <igloo@earth.li>**20080412132044] 
[(F)SLIT -> (f)sLit in MkId
Ian Lynagh <igloo@earth.li>**20080412131831] 
[(F)SLIT -> (f)sLit in Rules
Ian Lynagh <igloo@earth.li>**20080412131707] 
[(F)SLIT -> (f)sLit in PrelRules
Ian Lynagh <igloo@earth.li>**20080412131612] 
[(F)SLIT -> (f)sLit in HsSyn
Ian Lynagh <igloo@earth.li>**20080412130737] 
[(F)SLIT -> (f)sLit in HsUtils
Ian Lynagh <igloo@earth.li>**20080412125320] 
[(F)SLIT -> (f)sLit in HsExpr
Ian Lynagh <igloo@earth.li>**20080412125229] 
[(F)SLIT -> (f)sLit in HsDecls
Ian Lynagh <igloo@earth.li>**20080412124928] 
[(F)SLIT -> (f)sLit in HsImpExp
Ian Lynagh <igloo@earth.li>**20080412124840] 
[(F)SLIT -> (f)sLit in HsPat
Ian Lynagh <igloo@earth.li>**20080412124758] 
[(F)SLIT -> (f)sLit in HsTypes
Ian Lynagh <igloo@earth.li>**20080412124645] 
[(F)SLIT -> (f)sLit in IfaceSyn
Ian Lynagh <igloo@earth.li>**20080412124607] 
[(F)SLIT -> (f)sLit in IfaceType
Ian Lynagh <igloo@earth.li>**20080412124507] 
[(F)SLIT -> (f)sLit in CoreUnfold
Ian Lynagh <igloo@earth.li>**20080412124420] 
[(F)SLIT -> (f)sLit in CoreLint
Ian Lynagh <igloo@earth.li>**20080412124339] 
[(F)SLIT -> (f)sLit in CoreUtils
Ian Lynagh <igloo@earth.li>**20080412124218] 
[(F)SLIT -> (f)sLit in PprCore
Ian Lynagh <igloo@earth.li>**20080412124141] 
[(F)SLIT -> (f)sLit in Id
Ian Lynagh <igloo@earth.li>**20080412123952] 
[(F)SLIT -> (f)sLit in TcType
Ian Lynagh <igloo@earth.li>**20080412123745] 
[(F)SLIT -> (f)sLit in IdInfo
Ian Lynagh <igloo@earth.li>**20080412123637] 
[(F)SLIT -> (f)sLit in CoreSyn
Ian Lynagh <igloo@earth.li>**20080412123507] 
[(F)SLIT -> (f)sLit in CostCentre
Ian Lynagh <igloo@earth.li>**20080412123402] 
[(F)SLIT -> (f)sLit in Literal
Ian Lynagh <igloo@earth.li>**20080412123322] 
[Generate fsLit not FSLIT in genprimopcode
Ian Lynagh <igloo@earth.li>**20080412123247] 
[(F)SLIT -> (f)sLit in TysWiredIn
Ian Lynagh <igloo@earth.li>**20080412122946] 
[(F)SLIT -> (f)sLit in TysPrim
Ian Lynagh <igloo@earth.li>**20080412122846] 
[(F)SLIT -> (f)sLit in ForeignCall
Ian Lynagh <igloo@earth.li>**20080412122757] 
[(F)SLIT -> (f)sLit in DataCon
Ian Lynagh <igloo@earth.li>**20080412122709] 
[(F)SLIT -> (f)sLit in Coercion
Ian Lynagh <igloo@earth.li>**20080412122627] 
[(F)SLIT -> (f)sLit in Type
Ian Lynagh <igloo@earth.li>**20080412122524] 
[(F)SLIT -> (f)sLit in TypeRep
Ian Lynagh <igloo@earth.li>**20080412122409] 
[(F)SLIT -> (f)sLit in VarEnv
Ian Lynagh <igloo@earth.li>**20080412121437] 
[(F)SLIT -> (f)sLit in Class
Ian Lynagh <igloo@earth.li>**20080412121245] 
[(F)SLIT -> (f)sLit in Class
Ian Lynagh <igloo@earth.li>**20080412121211] 
[(F)SLIT -> (f)sLit in Var
Ian Lynagh <igloo@earth.li>**20080412121140] 
[(F)SLIT -> (f)sLit in Name
Ian Lynagh <igloo@earth.li>**20080412121050] 
[(F)SLIT -> (f)sLit in OccName
Ian Lynagh <igloo@earth.li>**20080412121008] 
[(F)SLIT -> (f)sLit in SrcLoc
Ian Lynagh <igloo@earth.li>**20080412120909] 
[(F)SLIT -> (f)sLit in Module
Ian Lynagh <igloo@earth.li>**20080412120817] 
[(F)SLIT -> (f)sLit in BasicTypes
Ian Lynagh <igloo@earth.li>**20080412120745] 
[(F)SLIT -> (f)sLit in Outputable
Ian Lynagh <igloo@earth.li>**20080412120538] 
[SLIT -> sLit in Prety.lhs
Ian Lynagh <igloo@earth.li>**20080412120004] 
[Don't use CPP for SLIT/FSLIT
Ian Lynagh <igloo@earth.li>**20080412115745] 
[Simplify SimplCont, plus some other small changes to the Simplifier
simonpj@microsoft.com**20080422120400
 
 The main change in this patch is this:
   
   * The Stop constructor of SimplCont no longer contains the OutType
     of the whole continuation.  This is a nice simplification in 
     lots of places where we build a Stop continuation.  For example,
     rebuildCall no longer needs to maintain the type of the function.
 
   * Similarly StrictArg no longer needs an OutType
 
   * The consequential complication is that contResultType (not called
     much) needs to be given the type of the thing in the middle.  No
     big deal.
 
   * Lots of other small knock-on effects
 
 Other changes in here
 
   * simplLazyBind does do the type-abstraction thing if there's
     a lambda inside.  See comments in simplLazyBind
 
   * simplLazyBind reduces simplifier iterations by keeping 
     unfolding information for stuff for which type abstraction is 
     done (see add_poly_bind)
 
 All of this came up when implementing System IF, but seems worth applying
 to the HEAD
 
] 
[Comments only in SimplCore
simonpj@microsoft.com**20080422120304] 
[Comments only
simonpj@microsoft.com**20080422120143] 
[Minor bug in SpecConstr
simonpj@microsoft.com**20080422115238
 
 In SpecConstr.isValue, we recorded a ConVal for a big-lambda,
 which seems wrong. I came across this when implementing System IF.
 The code now reads:
 
   isValue env (Lam b e)
     | isTyVar b = case isValue env e of
                    Just _  -> Just LambdaVal   -- NB!
                    Nothing -> Nothing
     | otherwise = Just LambdaVal
 
] 
[Comments only
simonpj@microsoft.com**20080422115221] 
[Fix a long-standing bug in FloatOut
simonpj@microsoft.com**20080422115003
 
 We really should not float anything out of an _inline_me_ Note,
 for reasons described in this new comment:
        -- Do no floating at all inside INLINE.
        -- The SetLevels pass did not clone the bindings, so it's
        -- unsafe to do any floating, even if we dump the results
        -- inside the Note (which is what we used to do).
 
 I'm about to get rid of these _inline_me_ Notes, but it's
 better to fix it anyway.  I found this bug when implementing System IF.
 
] 
[Remove static flag opt_RuntimeTypes (has not been used in years)
simonpj@microsoft.com**20080422114848] 
[Refactor the TyVarTy case of 'match'.  No change in behaviour.
simonpj@microsoft.com**20080422113014] 
[Add Note [Generating the in-scope set for a substitution]
simonpj@microsoft.com**20080422112925] 
[Rename WpCo to WpCast
simonpj@microsoft.com**20080422112804] 
[Fix #2044 (:printing impredicatively typed things)
pepe <mnislaih@gmail.com>**20080421171322
 
 Switching to boxyUnify should be enough to fix this.
] 
[Improve External Core syntax for newtypes
Tim Chevalier <chevalier@alum.wellesley.edu>**20080422045244
 
 I was confused by the newtype eta-contraction trick before.
 Newtype declarations are much less redundant now.
] 
[Update External Core docs
Tim Chevalier <chevalier@alum.wellesley.edu>**20080422044342
 
 Update documentation to reflect GHC HEAD.
] 
[External Core typechecker - improve handling of coercions
Tim Chevalier <chevalier@alum.wellesley.edu>**20080422015622
 
 Reorganized coercion-related code in the typechecker (this was
 brought about by typechecking the Core versions of the optimized GHC
 libraries.) A few miscellaneous changes (fixed a bug in Prep involving
 eta-expanding partial applications that had additional type
 arguments.)
] 
[Naming changes in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080422012734
 
 Two changes:
 - Top-level bindings in a given module are now printed as a 
   single %rec group. I found that in External Core generated from
   optimized code, nonrec bindings weren't being printed in
   dependency order. Rather than fixing that, I decided to not
   even pretend to preserve dependency order (since there's
   recursion between modules anyway.)
 
 - Internal names are now printed with their uniques attached
   (otherwise, GHC was printing out code with shadowed bindings,
   and this isn't supposed to happen in External Core.)
] 
[Add clarifying comments about unsafeCoerce
simonpj@microsoft.com**20080421152130] 
[Make the integer library to use more configurable
Ian Lynagh <igloo@earth.li>**20080420195856
 Now you just set INTEGER_LIBRARY=integer-foo in build.mk
] 
[Remove some duplicate extern decls
Ian Lynagh <igloo@earth.li>**20080416162330] 
[Add some more generic (en|de)code(Double|Float) code
Ian Lynagh <igloo@earth.li>**20080417171943] 
[Updates to handle Ordering moving from base to ghc-prim
Ian Lynagh <igloo@earth.li>**20080412100657] 
[Fix lndir
Ian Lynagh <igloo@earth.li>**20080408193436
 It would copy when it should symlink, and vice-versa.
] 
[Improve External Core syntax
Tim Chevalier <chevalier@alum.wellesley.edu>**20080416000347
 
 Got rid of the silly '^' characters before qualified names (plus:
 reverts to the original syntax; minus: makes the parser a little
 hairier.)
 
 Also, added warning in the typechecker for coercion kind mismatches
 rather than considering that a type error. (see the added comment in
 Check.hs for details.)
] 
[FIX BUILD (Windows): Copy the ln trick used by the GMP build
Simon Marlow <simonmar@microsoft.com>**20080414173225] 
[Revive the static argument transformation
simonpj@microsoft.com**20080411162137
 
 This patch revives the Static Argument Transformation, thanks to
 Max Bolingbroke.  It is enabled with 
        -fstatic-argument-transformation
 or     -O2
 
 Headline nofib results
 
                   Size    Allocs   Runtime
 Min             +0.0%    -13.7%    -21.4%
 Max             +0.1%     +0.0%     +5.4%
 Geometric Mean  +0.0%     -0.2%     -6.9%
 
 
] 
[Transfer strictness and arity info when abstracting over type variables
simonpj@microsoft.com**20080411142418
 
 See Note [transferPolyIdInfo] in Id.lhs, and test 
        eyeball/demand-on-polymorphic-floatouts.hs
 
 Max Bolingbroke discovered that we were gratuitiously losing strictness
 info.  This simple patch fixes it.  But see the above note for things
 that are still discarded: worker info and rules.
 
] 
[Revive External Core typechecker
Tim Chevalier <chevalier@alum.wellesley.edu>**20080414024648
 
 The typechecker works again! Yay!
 
 Details upon request.
] 
[Eta-expand newtype coercions in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080414031654
 
 Typechecking External Core is easier if we eta-expand axioms
 in newtype declarations. For a fuller explanation, see:
 http://www.haskell.org/pipermail/cvs-ghc/2008-April/041948.html
] 
[Extra info in genprimopcode --make-ext-core-source
Tim Chevalier <chevalier@alum.wellesley.edu>**20080414025407
 
 The ext-core typechecker needs to know what types are
 valid for various kinds of literals, so I changed 
 genprimopcode to dump out that information as well
 with --make-ext-core-source.
] 
[Fixing HPCTIXDIR problem with mkdir usage on Windows
andy@galois.com**20080411220510] 
[Update .darcs-boring with utils/ext-core stuff
Tim Chevalier <chevalier@alum.wellesley.edu>**20080411185734] 
[FIX #2197: an update frame might point to an IND_OLDGEN
Simon Marlow <simonmar@microsoft.com>**20080411173404] 
[Rejig error reporting in the unifier slightly
simonpj@microsoft.com**20080411132350] 
[Improve error message layout slightly
simonpj@microsoft.com**20080410113105] 
[Two improvements to boxy matching
simonpj@microsoft.com**20080410112812
 
 I can't quite remember what provoked these two changes, but they are in my
 tree.  
        One improves boxy_match (which failed unnecessarily)
        One fixes boxy_lub (which was assymetrical)
 
] 
[Fix Trac #2206: ensure the return type is rigid in a GADT match
simonpj@microsoft.com**20080410111514
 
] 
[Fix Trac #2205, which I introduced recently
simonpj@microsoft.com**20080410094336] 
[Ensure that arity is accurate in back end
simonpj@microsoft.com**20080410084930
 
 See Note [exprArity invariant] in CoreUtils.  In code generated by Happy
 I was seeing this after TidyPgm and CorePrep
 
        f :: Any
        f {arity 1} = id `cast` unsafe-co
 
 So f claimed to have arity 1 (because exprArity looked inside), but
 did not have any top-level lambdas (because its type is Any).  
 
 This triggered a slightly-obscure ASSERT failure in CoreToStg
 
 This patch 
        - makes exprArity trim the arity if the type is not a function
        - adds a stronger ASSERT in TidyPgm
 
 It's not the only way to solve this problem (see Note [exprArity invariant])
 but it's enough for now. 
 
] 
[Make the arity and strictness agree, for wired-in bottoming Ids
simonpj@microsoft.com**20080410082619] 
[Fix bug in vectorisation of case expressions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080411045307] 
[Extend genprimopcode to print primop types for ext-core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080410185810
 
 I added a new flag, --make-ext-core-source, to genprimopcode. It prints out the
 type information for primops that the External Core typechecker needs. This
 replaces the old mechanism where the ext-core tools had a hard-wired Prims
 module that could get out of sync with the old primops.txt. Now, that won't happen.
] 
[add pointers to the wiki for the rules about C prototypes
Simon Marlow <simonmar@microsoft.com>**20080409204143] 
[avoid warnings from ffi.h when UseLibFFIForAdjustors=YES
Simon Marlow <simonmar@microsoft.com>**20080409204048] 
[FIX BUILD (bootstrap with -fvia-C): prototype fixes
Simon Marlow <simonmar@microsoft.com>**20080409203724
 
] 
[Another round of External Core fixes
Tim Chevalier <chevalier@alum.wellesley.edu>**20080410043727
 
 With this patch, GHC should now be printing External Core in a format
 that a stand-alone program can parse and typecheck. Major bug fixes:
 
 - The printer now handles qualified/unqualified declarations correctly
    (particularly data constructor declarations)
 - It prints newtype declarations with enough information to
   typecheck code that uses the induced coercions (this required a
 syntax change)
 - It expands type synonyms correctly
  
 Documentation and external tool patches will follow.
 
] 
[Adding environment variable HPCTIXDIR, a directory to place tix results.
andy@galois.com**20080408232450] 
[Fixing hpc combine and hpc map to use the correct help message
andy@galois.com**20080408232032] 
[Import libffi-3.0.4, and use it to provide FFI support in GHCi
Simon Marlow <simonmar@microsoft.com>**20080408183434
 
 This replaces the hand-rolled architecture-specific FFI support in
 GHCi with the standard libffi as used in GCJ, Python and other
 projects.  I've bundled the complete libffi-3.0.4 tarball in the
 source tree in the same way as we do for GMP, the difference being
 that we always build and install our own libffi regardless of whether
 there's one on the system (it's small, and we don't want
 dependency/versioning headaches).
 
 In particular this means that unregisterised builds will now have a
 fully working GHCi including FFI out of the box, provided libffi
 supports the platform.
 
 There is also code in the RTS to use libffi in place of
 rts/Adjustor.c, but it is currently not enabled if we already have
 support in Adjustor.c for the current platform.  We need to assess the
 performance impact before using libffi here too (in GHCi we don't care
 too much about performance).
] 
[FIX BUILD on non-x86: add missing prototypes
Simon Marlow <simonmar@microsoft.com>**20080407213748] 
[update a comment
Simon Marlow <simonmar@microsoft.com>**20080407212437] 
[remove dead code
Simon Marlow <simonmar@microsoft.com>**20080403223422] 
[Replace one occurance of CVS with darcs in HACKING
Samuel Bronson <naesten@gmail.com>**20080407222006] 
[Remove GADT refinements, part 5
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080407070728
 - TcGadt RIP
 - The non-side effecting unification code is now in types/Unify.lhs
   along with the refinement code needed for GADT record selectors.
] 
[Remove GADT refinements, part 4
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080303063347
 - MkId.mkRecordSelId only used a special case of refineGadt, which doesn't
   need full unification.  That special case is now implemented as 
   TcGadt.matchRefine and TcGadt.refineGadt can finally go.
] 
[Improve error message for malformed LANGUAGE pragma
Tim Chevalier <chevalier@alum.wellesley.edu>**20080406202333
 
 I made the error (which previously said "cannot parse LANGUAGE
 pragma") slightly more helpful by reminding the user that pragmas
 should be comma-separated.
] 
[Improve error message for non-matching file name
Tim Chevalier <chevalier@alum.wellesley.edu>**20080406193821
 
 I changed the "File name does not match module name" error message so
 that it prints out both the declared module name and the expected
 module name (before, it was only printing the declared module name.)
] 
[Virtualize the cwd in GHCi
Pepe Iborra <mnislaih@gmail.com>**20080405145136
 
 This fixes the issue where :list would stop working if the
 program being debugged side-effected the working directory,
 and should prevent other similar issues
 
] 
[Fix rendering of references in :print under -fprint-evld-with-show flag
Pepe Iborra <mnislaih@gmail.com>**20071219174431] 
[Fix Trac #2188: scoping in TH declarations quotes
simonpj@microsoft.com**20080404205556
 
 This patch fixes a rather tiresome issue, namely the fact that
 a TH declaration quote *shadows* bindings in outer scopes:
 
   f g = [d| f :: Int
             f = g
            g :: Int
             g = 4 |]
 
 Here, the outer bindings for 'f' (top-level) and 'g' (local)
 are shadowed, and the inner bindings for f,g should not be
 reported as duplicates.  (Remember they are top-level bindings.)
 
 The actual bug was that we'd forgotten to delete 'g' from the
 LocalRdrEnv, so the type sig for 'g' was binding to the outer
 'g' not the inner one.
 
] 
[Fix simplifier thrashing
simonpj@microsoft.com**20080403223819
 
 Another example of the simplifier thrashing, getting nowhere.
 See SimplUtils, Note [Unsaturated functions]
 
 There's a test at eyeball/inline4.hs
 
] 
[Fix Trac #2179: error message for main
simonpj@microsoft.com**20080403173746
 
 A short-cut to generate the (runMainIO main) wrapper turned out
 to make a bad error message.  This should fix it.
 
] 
[Fix Trac #2136: reporting of unused variables
simonpj@microsoft.com**20080403110250
 
 There's a bit of a hack RnBinds.rnValBindsAndThen, documented
 in Note [Unused binding hack].  But the hack was over brutal
 before, and produced unnecssarily bad (absence of) warnings.
 This patch does a bit of refactoring; and fixes the bug in
 rnValBindsAndThen.
 
] 
[Fix Trac #2137: report correct location for shadowed binding
simonpj@microsoft.com**20080402153410
 
 The error message generation for a shadowed binding was
 plain wrong, at least where the shadowed binding isn't
 top-level.  Just a typo really -- the fix is trivial.
 
] 
[Fix Trac #2141: invalid record update
simonpj@microsoft.com**20080402132057
 
 See Note [Record field lookup] in TcEnv.  The fix here
 is quite straightforward.
 
] 
[Do not #include external header files when compiling via C
Simon Marlow <simonmar@microsoft.com>**20080402051412
 
 This has several advantages:
 
  - -fvia-C is consistent with -fasm with respect to FFI declarations:
    both bind to the ABI, not the API.
 
  - foreign calls can now be inlined freely across module boundaries, since
    a header file is not required when compiling the call.
 
  - bootstrapping via C will be more reliable, because this difference
    in behavour between the two backends has been removed.
 
 There is one disadvantage:
 
  - we get no checking by the C compiler that the FFI declaration
    is correct.
 
 So now, the c-includes field in a .cabal file is always ignored by
 GHC, as are header files specified in an FFI declaration.  This was
 previously the case only for -fasm compilations, now it is also the
 case for -fvia-C too.
] 
[Derive a valid Ix instance for data Foo = Foo Int Int
Ian Lynagh <igloo@earth.li>**20080330182813
 The old one didn't satisfy the axioms. See trac #2158 for details.
] 
[Revive External Core parser
Tim Chevalier <chevalier@alum.wellesley.edu>**20080329223948
 
 Huzzah, the External Core parser will now parse External Core generated by
 the HEAD.
 
 Most notably, I rewrote the parser in Parsec, but the old Happy version
 remains in the repository.
 
 I checked all the nofib benchmarks and most of the ghc-prim, base and integer
 libraries to make sure they parsed; one known bug:
   - Strings like "\x0aE", in which a hex escape code is followed by a
     letter that could be a hex digit, aren't handled properly. I'm 
     investigating whether this is a bug in Parsec or expected behavior.
 
 The checker and interpreter still don't work, but should compile.
 
 Please mess around with the parser, report bugs, improve my code, etc.,
 if you're so inclined.
 
] 
[Fix big character literal printing in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080329221109
 
 Characters bigger than '\xff' should be represented as int
 literals in External Core. (This was originally fixed five years ago
 and broken again four and a half years ago...)
] 
[External Core: don't print superfluous parens in case types
Tim Chevalier <chevalier@alum.wellesley.edu>**20080329194629
 
 The External Core printer was parenthesizing the scrutinee type in case expressions. Since this type is required to be atomic, the parens aren't necessary.
] 
[Don't import FastString in HsVersions.h
Ian Lynagh <igloo@earth.li>**20080329185043
 Modules that need it import it themselves instead.
] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329171135] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329171013] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329170935] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329170341] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329170227] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329165412] 
[Fix typo; spotted by Bdh in #ghc
Ian Lynagh <igloo@earth.li>**20080329165303] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329164849] 
[DEBUG removal
Ian Lynagh <igloo@earth.li>**20080329164420] 
[Remove a DEBUG use
Ian Lynagh <igloo@earth.li>**20080329164209] 
[Remove a DEBUG
Ian Lynagh <igloo@earth.li>**20080329163936] 
[Remove more #ifdef DEBUGs
Ian Lynagh <igloo@earth.li>**20080329145716] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329145508] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329145244] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329144844] 
[Remove a #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329144658] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329144544] 
[Remove some redundant code
Ian Lynagh <igloo@earth.li>**20080329144226] 
[prelude/PrimOp is now mostly warning-free
Ian Lynagh <igloo@earth.li>**20080329143914
 commutableOp seems to be unused, so we're no 100% there yet.
] 
[Fix warnings from primops.txt.pp
Ian Lynagh <igloo@earth.li>**20080329142637] 
[Use _ rather than "other" in generated code
Ian Lynagh <igloo@earth.li>**20080329142508] 
[Fix some warnings
Ian Lynagh <igloo@earth.li>**20080329142219] 
[Remove some redundant imports
Ian Lynagh <igloo@earth.li>**20080329141809] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329141733] 
[Remove an #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329141629] 
[Remove some unnecessary imports
Ian Lynagh <igloo@earth.li>**20080329141145] 
[Remove an unnecessary #ifdef DEBUG
Ian Lynagh <igloo@earth.li>**20080329141047] 
[Another debugIsOn use
Ian Lynagh <igloo@earth.li>**20080329140126] 
[Convert some DEBUG uses to debugIsOn
Ian Lynagh <igloo@earth.li>**20080329135950] 
[Put debugIsOn in Util, rather than rely on it being CPPed in
Ian Lynagh <igloo@earth.li>**20080329135755] 
[External Core: print function types correctly, improve newtype pretty-printing
Tim Chevalier <chevalier@alum.wellesley.edu>**20080328222630
 
 - In a previous patch I broke the printing of fully-applied arrow
 types (e.g., "a -> b" was "(ghczmprim:GHCziPrim a b)") by z-encoding
 package names and not updating the primitive module name as defined in
 External Core accordingly. Fixed. (Mega sigh...)
 
 - Make newtype decls print slightly more readably.
] 
[Print out rational literals correctly in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080328211919
 
 The External Core printer was printing out rational literals of the
 form: 
 2.0e-2
 when the External Core grammar doesn't allow this. (This
 bug has apparently been there since the beginning...)
 
 It's now printing rationals in the same form that (show (r::Rational))
 does. This requires a parser change as well (soon to come.)
] 
[Change syntax for qualified names in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080327185436
 
 Two changes that make the ext-core code uglier but the parser easier:
 
 - Prefix qualified names with "^" so that we can more easily
 distinguish a qualified name:
    ^a:Foo.Bar.quux 
 from an unqualified name:
    a
 
 - z-encode package names ("ghc-prim" was the culprit.)
] 
[Make use of the SDoc type synonym
Ian Lynagh <igloo@earth.li>**20080326175306] 
[Fix warnings in rename/RnTypes
Ian Lynagh <igloo@earth.li>**20080326174657] 
[Fix warnings in basicTypes/IdInfo
Ian Lynagh <igloo@earth.li>**20080326170014] 
[Fix warnings in basicTypes/NameEnv
Ian Lynagh <igloo@earth.li>**20080326165139] 
[Fix warnings in basicTypes/NameSet
Ian Lynagh <igloo@earth.li>**20080326164837] 
[Fix warning in basicTypes/NewDemand
Ian Lynagh <igloo@earth.li>**20080326160017] 
[Fix warnings in basicTypes/VarEnv
Ian Lynagh <igloo@earth.li>**20080326155412] 
[Fix warnings in basicTypes/VarSet
Ian Lynagh <igloo@earth.li>**20080326155105] 
[main/BreakArray has no warnings
Ian Lynagh <igloo@earth.li>**20080326154747] 
[In validate settings, make -Werror easier to override
Ian Lynagh <igloo@earth.li>**20080326141030] 
[Remove a redundant type sig
Ian Lynagh <igloo@earth.li>**20080326004932] 
[Fix warnings in main/DriverPhases
Ian Lynagh <igloo@earth.li>**20080325235828] 
[Remove redundant type sig
Ian Lynagh <igloo@earth.li>**20080325235801] 
[Fix warnings in main/HscStats
Ian Lynagh <igloo@earth.li>**20080325234110] 
[Fix warnings in main/Constants
Ian Lynagh <igloo@earth.li>**20080325233034] 
[Fix warnings in main/InteractiveEval
Ian Lynagh <igloo@earth.li>**20080325230153] 
[Fix warnings in main/Packages
Ian Lynagh <igloo@earth.li>**20080325224444] 
[Fix warnings in main/PprTyThing
Ian Lynagh <igloo@earth.li>**20080325223104] 
[Fix warnings in main/StaticFlags
Ian Lynagh <igloo@earth.li>**20080325221632] 
[Change syntax for newtypes in External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080325170218
 
 The way that newtype declarations were printed in External Core files was
 incomplete, since there was no declaration for the coercion introduced by a
 newtype.
 
 For example, the Haskell source:
 
 newtype T a = MkT (a -> a)
 
 foo (MkT x) = x
 
 got printed out in External Core as (roughly):
 
   %newtype T a = a -> a;
 
   foo :: %forall t . T t -> t -> t =
     %cast (\ @ t -> a1 @ t)
     (%forall t . T t -> ZCCoT t);
 
 There is no declaration anywhere in the External Core program for :CoT, so
 that's bad.
 
 I changed the newtype decl syntax so as to include the declaration for the
 coercion axiom introduced by the newtype. Now, it looks like:
 
   %newtype T a ^ (ZCCoT :: ((T a) :=: (a -> a))) = a -> a;
 
 And an external typechecker could conceivably typecheck code that uses this.
 
 The major changes are to MkExternalCore and PprExternalCore (as well as
 ExternalCore, to change the External Core AST.) I also corrected some typos in
 comments in other files.
 
 Documentation and external tool changes to follow.
 
] 
[Fix warnings in the RTS
Ian Lynagh <igloo@earth.li>**20080325160314
 For some reason this causes build failures for me in my 32-bit chroot,
] 
[Another change for GHC.PrimopWrappers moving from base to ghc-prim
Ian Lynagh <igloo@earth.li>**20080324224006] 
[Update darcs-boring
Ian Lynagh <igloo@earth.li>**20080324212319] 
[Fix primMname in External Core printer
Tim Chevalier <chevalier@alum.wellesley.edu>**20080324014311
 
  My earlier changes broke printing of function types in .hcr files.
   In other words: the z-encoding must die.
] 
[Fix primMname in External Core printer
Tim Chevalier <chevalier@alum.wellesley.edu>**20080324005246
 
 My earlier changes broke printing of function types in .hcr files.
 In other words: the z-encoding must die.
] 
[Follow library changes
Ian Lynagh <igloo@earth.li>**20080323182557
 Integer, Bool and Unit/Inl/Inr are now in new packages integer
 and ghc-prim.
] 
[CgTicky now doesn't know about the Integer data constructors
Ian Lynagh <igloo@earth.li>**20080320195836] 
[-DDEBUG build fix
Ian Lynagh <igloo@earth.li>**20080322140641] 
[Rename rebuild to remake, and define rebuild to "clean; build"
Ian Lynagh <igloo@earth.li>**20080320221915] 
[Handle hierarchical module names in External Core tools
Tim Chevalier <chevalier@alum.wellesley.edu>**20080320014449
 
 I updated the parser to handle hierarchical module names (with package names)
 the way GHC is currently printing them out in External Core.
 
 Beware kludgy use of z-encoding and gratutious copy-pasta from GHC.
 
 You can now use the stand-alone Core parser to parse a very simple
 GHC-generated .hcr file (progress!) but not to typecheck or interpret it
 (the typechecker/interpreter don't snarf in the right libraries yet, among
 other things.) And, the parser is still incomplete in that it doesn't handle
 programs with newtypes/GADTs/etc. whose syntax has changed since 2003. In
 other words: probably don't try to use this yet.
 
] 
[Improve hierarchical module name handling in MkExternalCore
Tim Chevalier <chevalier@alum.wellesley.edu>**20080319190429
 
 It's easier for the External Core parser if MkExternalCore prints
 module names like:
    base:GHCziBase
 rather than like:
    base:GHC.Base
 (which it was doing before.)
 
 So now we z-encode the hierarchical module-name part of a module
 name, but don't z-encode the ':'.
 
 I also removed some old comments that don't seem relevant anymore.
] 
[Fixed remaining warning in coreSyn/MkExternalCore
Tim Chevalier <chevalier@alum.wellesley.edu>**20080319182521
 
 There was a (suppressed) warning about an incomplete pattern match in make_alt. This was because the DEFAULT alt never has variable bindings. I thought it would be better to check that case and panic if it happens than to have an incomplete pattern. It's still not great, but at least now we don't have to suppress any warnings in this file.
] 
[Revert an accidental change
Ian Lynagh <igloo@earth.li>**20080317200130] 
[Print some extra debugging info when doing --show-iface
Ian Lynagh <igloo@earth.li>**20080317185032] 
[Eliminate a global variable
Ian Lynagh <igloo@earth.li>**20080317180150
 Very little parameter passing is needed without it, so there was no real
 benefit to it.
] 
[Follow changes in editline
Ian Lynagh <igloo@earth.li>**20080317103617] 
[Use editline instead of readline
Ian Lynagh <igloo@earth.li>**20080316060407] 
[Vectorise tuple constructorsn
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080317033436] 
[Added double divide and unzipP
keller@cse.unsw.edu.au**20080317025553] 
[Added 'div' to set of vectorising functions
keller@cse.unsw.edu.au**20080311125035] 
[If unregisterised, link with -optl-Wl,--relax on IA64
Ian Lynagh <igloo@earth.li>**20080316214104
 This fixes part of trac #856
] 
[When concatenating variables in Makefile, strip spaces in case one is empty
Ian Lynagh <igloo@earth.li>**20080315141751
 Otherwise "$(A) $(B)" will not be equal to "" even if A and B are empty.
 Trac #856.
] 
[Fix a space leak in :trace (trac #2128)
Ian Lynagh <igloo@earth.li>**20080316211748
 We were doing lots of cons'ing and tail'ing without forcing the tails,
 so were building up lots of thunks.
] 
[If we are failing due to a warning and -Werror, say so
Ian Lynagh <igloo@earth.li>**20080316195636
 Fixes trac #1893, based on a patch from Daniel Franke.
] 
[Remove leftover NoteTy/FTVNote bits
Ian Lynagh <igloo@earth.li>**20080315194220] 
[Remove uses of addFreeTyVars
Ian Lynagh <igloo@earth.li>**20080315155027
 This optimisation actually make things a bit slower on average, as
 measured by nofib. The example in #1136 in particular suffers from high
 memory usage. Therefore we no longer do the optimisation.
] 
[parsing tweak for :break
Simon Marlow <simonmar@microsoft.com>**20080313182936] 
[Tweaks to stack squeezing
Simon Marlow <simonmar@microsoft.com>**20080207122445
 
 1. We weren't squeezing two frames if one of them was a marked update
    frame.  This is easy to fix.
 
 2. The heuristic to decide whether to squeeze was a little
    conservative.  It's worth copying 3 words to save an update frame.
  
] 
[Some cleanup in TcSimplify.reduceContext
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080313065220
 - Makes this horrid function a bit better - and shorter!
 - Also gets rid of another API function of TcTyFuns
] 
[Properly normalise reduced dicts
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080313051708
 - Another chapter in the never-ending TcSimplify.reduceContext saga: after
   context reduction of wanted dicts it is not sufficient to normalise them
   wrt to the wanted equalities.  We also need to take top-level equalities
   into account.  (In fact, we probably also have to normalise wrt to given
   equalities, but I have left that open for the moment - but added a TODO
   note.)
 - This finally eliminates substEqInDictInsts from TcTyFuns interface and
   suggest some further possible clean up (which will be in a separate patch).
 
 Thanks to Roman for the intricate example that uncovered this bug.
] 
[Bump mAX_NDP_PROD to 5
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080313061411] 
[#2050: save the GHCi history in ~/.ghc/ghci_history
Simon Marlow <simonmar@microsoft.com>**20080312215724
 Modified version of Judah's patch
] 
[Make sure we generate PA dictionaries for tuples up to mAX_NDP_PROD
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080312034905] 
[Bump mAX_NDP_PROD to 4
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080312030245] 
[First cut at reviving the External Core tools
Tim Chevalier <chevalier@alum.wellesley.edu>**20080310025821
 
 I updated the External Core AST to be somewhat closer to reality (where reality is defined by the HEAD), and got all the code to compile under GHC 6.8.1. (That means it works, right?)
 
 Major changes:
 
 - Added a Makefile.
 
 - Core AST:
     - Represented package names and qualified module names.
     - Added type annotation on Case exps.
     - Changed Coerce to Cast.
     - Cleaned up representation of qualified/unqualified names.
     - Fixed up wired-in module names (no more "PrelGHC", etc.)
 
 - Updated parser/interpreter/typechecker/prep for the new AST.
 
 - Typechecker:
     - Used a Reader monad to pass around the global environment and top module name.
     - Added an entry point to check a single expression.
 
 - Prep:
     - Got rid of typeofExp; it's now defined in terms of the typechecker.
 
] 
[Remove ndpFlatten
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080309225914
 
 This patch removes the ndpFlatten directory and the -fflatten static flag.
 This code has never worked and has now been superceded by vectorisation.
] 
[documentation fix: change flag -frules-off to -fno-rewrite-rules
iavor.diatchki@gmail.com**20080309191911] 
[Don't expose the unfolding of dictionary selectors without -O
simonpj@microsoft.com**20080306135026
 
 When compiling without -O we were getting code like this
 
        f x = case GHC.Base.$f20 of
                  :DEq eq neq -> eq x x
 
 But because of the -O the $f20 dictionary is not available, so exposing
 the dictionary selector was useless.  Yet it makes the code bigger!
 Better to get
        f x = GHC.Base.== GHC.Bsae.$f20 x x
 
 This patch suppresses the implicit unfolding for dictionary selectors
 when compiling without -O.  We could do the same for other implicit
 Ids, but this will do for now.
 
 There should be no effect when compiling with -O.  Programs should
 be smaller without -O and may run a tiny bit slower.
 
 
] 
[Fix Trac #783: improve short-cutting literals in the type checker
simonpj@microsoft.com**20080306134734
 
 The Inst.shortCutIntLit mechanism in the type checker was missing cases
 where a floating-point literal was given without an explicit decimal point.
 
 As a result, programs with lots of floating-point literals (without decimals)
 ended up with massive Static Reference Tables.  This is not cool.  See
 comments with Trac #783 for details.
 
 
] 
[Fix Trac #2138: print the 'stupid theta' of a data type
simonpj@microsoft.com**20080306134651] 
[Fix vectorisation monad
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080307050859] 
[Improve SpecConstr for local bindings: seed specialisation from the calls
simonpj@microsoft.com**20080306120004
 
 This patch makes a significant improvement to SpecConstr, based on
 Roman's experience with using it for stream fusion.  The main change is
 this:
 
   * For local (not-top-level) declarations, seed the specialisation 
     loop from the calls in the body of the 'let'.
 
 See Note [Local recursive groups] for discussion and example.  Top-level
 declarations are treated just as before.
 
 Other changes in this patch:
 
   * New flag -fspec-constr-count=N sets the maximum number of specialisations
     for any single function to N.  -fno-spec-constr-count removes the limit.
 
   * Refactoring in specLoop and friends; new algebraic data types 
     OneSpec and SpecInfo instead of the tuples that were there before
 
   * Be less keen to specialise on variables that are simply in scope.
     Example
       f p q = letrec g a y = ...g....  in g q p
     We probably do not want to specialise 'g' for calls with exactly
     the arguments 'q' and 'p', since we know nothing about them.
 
 
] 
[Refactor OccAnal; and improve dead-code elimination
simonpj@microsoft.com**20080305155708
 
 The occurrence analyer is now really rather subtle when dealing
 with recursive groups; see Note [Loop breaking and RULES] especially.
 
 This patch refactors this code a bit, notably 
   * Introduces a new data type Details instead of a tuple
 
   * More clearly breaks up a recursive group into its SCCs
        before processing it in a separate function occAnalRec
 
   * As a result, does better dead-code elimination, becuause it's
        done per SCC rather than for the whole Rec
 
 
   
 
] 
[Copy the right ghc-pkg.bin into bindists
Ian Lynagh <igloo@earth.li>**20080305224020] 
[Add a missing endif to the bindist Makefile
Ian Lynagh <igloo@earth.li>**20080305221136] 
[Fix bashisms; patch from Bernie Pope
Ian Lynagh <igloo@earth.li>**20080305134556] 
[Improve no-type-signature warning
Ian Lynagh <igloo@earth.li>**20080305011242
 Instead of
    Warning: Definition but no type signature for `.+.'
             Inferred type: .+. :: forall a. a
 we now say
     Warning: Definition but no type signature for `.+.'
              Inferred type: (.+.) :: forall a. a
] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20080302151339] 
[In bindists, look in the right place to see if we have provided docs
Ian Lynagh <igloo@earth.li>**20080302140408
 Fixes trac #1971: unjustified warning about documentation
] 
[Remove GADT refinements, part 3
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080229035740] 
[MacOS installer: Uninstaller must be able to deal with ATiger receipts
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080228050707] 
[Add and use seqBitmap when constructing SRTs
Ian Lynagh <igloo@earth.li>**20080227144505
 This roughly halves memory usage when compiling
     module Foo where
 
     foo :: Double -> Int
     foo x | x == 1 = 1
     ...
     foo x | x == 500 = 500
 without optimisation.
] 
[Whitespace
Ian Lynagh <igloo@earth.li>**20080220191230] 
[Remove GADT refinements, part 2
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080228055326] 
[Fix Trac #2130: improve derived Ord for primmitive types
simonpj@microsoft.com**20080228121106
 
 This patch does two things:
 
 * (Minor): in TcGenDeriv.careful_compare_Case, test for less-than before
   equality. This should reduce the number of dynamic tests, and also gives
   more scope for optimisation, since less-than tells us more than equality.
 
 * (More important): add special-case derived code for data types that are
   simple wrappers of primitive types. See 
        Note [Comparision of primitive types]
   This fixes Trac 2130.
 
 However see also Trac #2132, which is not addressed here.
 
] 
[Comments only
simonpj@microsoft.com**20080228111301] 
[add a note about SMP execution not being supported with profiling
Simon Marlow <simonmar@microsoft.com>**20080228112209] 
[Enable -prof -threaded (#886)
Simon Marlow <simonmar@microsoft.com>**20080228111631
 It turns out that -prof -threaded works (modulo some small changes),
 because all the data structures used in profiling are only accessed by
 one thread at a time, at long as we don't use +RTS -N2 or higher.  So
 this patch enables the use of -prof -threaded, but an error is given
 if you ask for more than one CPU with +RTS -N.
] 
[Wibble to error message (stmt of do block or comprehension)
simonpj@microsoft.com**20080228083104] 
[Make explicit lists more fusable
Max Bolingbroke <batterseapower@hotmail.com>**20080228083050] 
[Add comments explaining flags
simonpj@microsoft.com**20080228082935] 
[Remove GADT refinements, part 1
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080228045351
 - A while ago, I changed the type checker to use equality constraints together
   with implication constraints to track local type refinement due to GADT
   pattern matching.  This patch is the first of a number of surgical strikes
   to remove the resulting dead code of the previous GADT refinement machinery.
 
   Hurray to code simplification!
] 
[Eliminate SkolemOccurs skolems only after checkLoop reached a fixed point
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080228001957
 - See test case indexed-types/should_fail/SkolemOccursLoop, which sends the
   type checker into an endless loop without this fix
] 
[Fix Trac #2126: re-order tests (easy)
simonpj@microsoft.com**20080227163202] 
[Fix Trac #2111: improve error handling for 'rec' in do-notation
simonpj@microsoft.com**20080226175635
 
 We were not dealing correctly with all the combinations of 
        do notation
        mdo notation
        arrow notation
 in combination with 'rec' Stmts.
 
 I think this patch sorts it out.
 
] 
[Remove gaw comment
simonpj@microsoft.com**20080226175305] 
[Fix Trac #1899; missing equality check in typechecker's constraint simplifier
simonpj@microsoft.com**20080226174743
 
 This patch fixes a missing equality check (uifying type variable b=b) in
 the new constraint simplifier in TcTyFuns.  As it stands, we were making
 'b' point to itself, which subsequently led to an infinite loop when
 zonking.  Test is T1899.hs
 
 
 
] 
[FIX #2122: file locking bug
Simon Marlow <simonmar@microsoft.com>**20080226104650
 Second and subsequent readers weren't being inserted into the
 fd->lock hash table, which meant that the file wasn't correctly
 unlocked when the Handles were closed.
] 
[documentation improvements from Frederik Eaton
Simon Marlow <simonmar@microsoft.com>**20080226102612] 
[markup fix
Simon Marlow <simonmar@microsoft.com>**20080226102558] 
[Mac installer: cross-compile for 10.4
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080225093734] 
[Make UniqFM non-strict again while we work out what we're doing.
Ian Lynagh <igloo@earth.li>**20080225171305
 This "fixes" the very-slow problem we have when compiling dictionaries.
] 
[Fix Trac #2082
simonpj@microsoft.com**20080219173410] 
[Fix Trac #2114: error reporting for 'forall' without appropriate flags
simonpj@microsoft.com**20080222182646] 
[Improve error messages from type-checking data constructors
simonpj@microsoft.com**20080222182514
 
 This addresses Trac #2112
 
] 
[Add type sigs and minor refactoring
simonpj@microsoft.com**20080222182305] 
[FIX #2073: Don't add empty lines to GHCI's history
Ian Lynagh <igloo@earth.li>**20080224143256] 
[FIX #1977: Check to see if $(bindir) is in the path
Ian Lynagh <igloo@earth.li>**20080224134334
 Before telling the user to add it, when installing a bindist, check to
 see if $(bindir) is already in the path.
] 
[Fix warnings in Simplify
Ian Lynagh <igloo@earth.li>**20080222150318] 
[Whitespace
Ian Lynagh <igloo@earth.li>**20080222140755] 
[Add a comment
Ian Lynagh <igloo@earth.li>**20080220205844] 
[Fix most of the warnings in StgLint
Ian Lynagh <igloo@earth.li>**20080220171858] 
[Whitespace
Ian Lynagh <igloo@earth.li>**20080220171140] 
[CprAnalyse is warning-free
Ian Lynagh <igloo@earth.li>**20080220170843] 
[Whitespace
Ian Lynagh <igloo@earth.li>**20080220170650] 
[Fix #1984: missing context switches
Simon Marlow <simonmar@microsoft.com>**20080219102212] 
[fix unregisterised stage 2 build
Simon Marlow <simonmar@microsoft.com>**20080219093407] 
[Mac OS X deployment target: piping opts through Makefiles
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080221224449] 
[Rewrite fixTvSubstEnv so it iteratively applies its substition
Ian Lynagh <igloo@earth.li>**20080220153752
 This fixes a stack overflow when using strict UniqFMs. It might be
 possible to rewrite it more efficiently, or to avoid needing it in the
 first place.
] 
[Typo
Ian Lynagh <igloo@earth.li>**20080219204117] 
[Make some more modules use LazyUniqFM instead of UniqFM
Ian Lynagh <igloo@earth.li>*-20080207015714
 If these modules use UniqFM then we get a stack overflow when compiling
 modules that use fundeps. I haven't tracked down the actual cause.
] 
[Add configure option --with-macos-deployment-target
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080219031755] 
[Fix warning in SCCfinal
Ian Lynagh <igloo@earth.li>**20080219020429] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080219015259] 
[Fix warnings in UniqSupply
Ian Lynagh <igloo@earth.li>**20080219013233] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080219012417] 
[Fix non-missing-signature warnings in MkId
Ian Lynagh <igloo@earth.li>**20080219010917] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080219005042] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218234559] 
[Make literals in the syntax tree strict
Ian Lynagh <igloo@earth.li>**20080218183424] 
[Make the parser a bit stricter
Ian Lynagh <igloo@earth.li>**20080218175514] 
[seq what we actually want to seq, not the seq'ing function
Ian Lynagh <igloo@earth.li>**20080213131857] 
[attempt to fix #2098 (PPC pepple please test & fix)
Simon Marlow <simonmar@microsoft.com>**20080218115748] 
[FIX #2023: substitute for $topdir in haddockInterfaces and haddockHTMLs
Simon Marlow <simonmar@microsoft.com>**20080209143648] 
[All installed Haskell prgms have an inplace and an installed version
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080218061809
 - GHC installs a range of compiled Haskell programs in addition to the actual
   compiler.  To ensure that they all run on the platform targeted by the build
   (which may have different libraries installed than the build host), we need
   to make sure that all compiled Haskell code going into an install is build
   with the stage 1 compiler, not the bootstrap compiler.  Getting this right
   is especially important on the Mac to enable builds that work on Mac OS X
   versions that are older than the one performing the build.
 - For all installed utils implemented in Haskell (i.e., ghc-pkg, hasktags,
   hsc2hs, runghc, hpc, and pwd) we compile two versions, an inplace version
   and a version for installation.  The former is build by the bootstrap
   compiler during the stage 1 build and the latter is build by the stage 1
   compiler during the stage 2 build.
 - This is really very much as the setup for ghc itself, only that we don't use
   separate stage1/ and stage2/ build directories.  Instead, we clean before
   each build.  CAVEAT: This only works properly if invoked from the 
   toplevel Makefile.
 - Instead of UseStage1=YES (as used by the previous binary-dist-specific
   recompilation), we now use the same $(stage) variables as used for the
   compiler proper - to increase uniformity and to avoid extra conditionals for
   the install target.
] 
[Fix warnings in Pretty
Ian Lynagh <igloo@earth.li>**20080218214151] 
[Fix warnings in FiniteMap
Ian Lynagh <igloo@earth.li>**20080218200408] 
[Fix warnings in Binary
Ian Lynagh <igloo@earth.li>**20080218193645] 
[Fix warnings in StringBuffer
Ian Lynagh <igloo@earth.li>**20080218191846] 
[Fix warnings in IOEnv
Ian Lynagh <igloo@earth.li>**20080218190849] 
[Fix warnings in FastString, and check for empty case in head/tail
Ian Lynagh <igloo@earth.li>**20080218144707] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218112232] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218112101] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218111941] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218110241] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218105909] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080218105343] 
[Tweak whitespace
Ian Lynagh <igloo@earth.li>**20080217175133] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20080217175021] 
[Print better error message for reading External Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20080217223844
 
 GHC panicked with a "Prelude.undefined" error message if you tried to
 compile a .hcr file. Since support for reading ExternalCore simply does
 not exist, I added an error message to say that.
 
 Please merge to 6.8. Thanks.
 
] 
[Documentation only: update External Core section of user guide
Tim Chevalier <chevalier@alum.wellesley.edu>**20080217213206
 
 I updated the External Core section of the user guide, mostly to reflect
 that the input path is broken and there are no firm plans to fix it. 
] 
[Generate foo(void) rather than foo() in FFI stub files
Ian Lynagh <igloo@earth.li>**20080216141031
 -Wstrict-prototypes warns about the latter.
 Patch from pcc in trac #2100.
] 
[Make hasktags -Wall clean
Ian Lynagh <igloo@earth.li>**20080215160309] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080215155122] 
[Fix building hasktags
Ian Lynagh <igloo@earth.li>**20080215154415] 
[Revert an accidental comment change
Ian Lynagh <igloo@earth.li>**20080215153558] 
[find module names, fix for get constructor names, find class names as well, sort ctag files
marco-oweber@gmx.de**20080212232157] 
[added TODO item and link to alternatives on wiki
marco-oweber@gmx.de**20080212231853] 
[Make more arch-specific #if's exclusive with #else #error cases
Duncan Coutts <duncan@haskell.org>**20080207170020
 So when the next person compiles the Sparc NCG it should fail more
 obviously at compile time rather than panicing at runtime.
 Plus one obvious fix for LocalReg gaining an extra param
 Missing bits of Sparc NCG:
   * genSwitch for generating jump tables. This is the most tricky one.
   * ALLOCATABLE_REGS_INTEGER and ALLOCATABLE_REGS_DOUBLE just requires
     finding and verifying the values. The nearby comment describes how.
   * isRegRegMove and mkRegRegMoveInstr. Sparc uses Or for int move, check
     what this is supposed to do for single and double float types.
   * regDotColor. Probably just copy the ppc impl.
] 
[Document code a bit better
Ian Lynagh <igloo@earth.li>**20080213161106] 
[Add a necessary [] error case
Ian Lynagh <igloo@earth.li>**20080213154232] 
[\e -> f e   ===>    f
Ian Lynagh <igloo@earth.li>**20080213153835] 
[Fixed warnings in parser/Lexer.x
Twan van Laarhoven <twanvl@gmail.com>**20080204021131
 
 The -w flag can not be removed, because alex also generates code with lots of warnings.
] 
[Monadification and Fixed warnings in parser/RdrHsSyn, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080204015053] 
[Fixed warnings in vectorise/VectMonad
Twan van Laarhoven <twanvl@gmail.com>**20080203223932] 
[Fix typo in message
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080212052219] 
[Remove old code to get TMPDIR, use System.Directory.getTemporaryDirectory
Simon Marlow <simonmar@microsoft.com>**20080207143915] 
[Mac installer: Added XCODE_EXTRA_CONFIGURE_ARGS
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080211115201] 
[Mac installer: make Uninstaller a bit more robust
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080211091119] 
[Mac installer: add comprehensive licencing information
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080211061450] 
[Force -s on ar in xcode builds
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080211022329] 
[Fix warning (FIX validate)
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080211040211] 
[Symbolic tags for simplifier phases
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080211032350
 
 Every simplifier phase can have an arbitrary number of tags and multiple
 phases can share the same tags. The tags can be used as arguments to
 -ddump-simpl-phases to specify which phases are to be dumped.
 For instance, -ddump-simpl-phases=main will dump the output of phases 2, 1 and
 0 of the initial simplifier run (they all share the "main" tag) while
 -ddump-simpl-phases=main:0 will dump only the output of phase 0 of that run.
 
 At the moment, the supported tags are:
 
   main                 The main, staged simplifier run (before strictness)
   post-worker-wrapper  After the w/w split
   post-liberate-case   After LiberateCase
   final                Final clean-up run
 
 The names are somewhat arbitrary and will change in the future.
] 
[Allow -ddump-simpl-phases to specify which phases to dump
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080211020630
 
 We can now say -ddump-simpl-phases=1,2 to dump only these two phases and
 nothing else.
] 
[Fixed warnings in parser/ParserCoreUtils
Twan van Laarhoven <twanvl@gmail.com>**20080204022226] 
[Fixed warnings in hsSyn/Convert, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080204000510] 
[Fixed warnings in types/Unify
Twan van Laarhoven <twanvl@gmail.com>**20080203224228] 
[Fixed warnings in ndpFlatten/FlattenInfo
Twan van Laarhoven <twanvl@gmail.com>**20080203224159] 
[Fixed warnings in vectorise/VectBuiltIn
Twan van Laarhoven <twanvl@gmail.com>**20080203224043] 
[Fixed warnings in vectorise/VectCore
Twan van Laarhoven <twanvl@gmail.com>**20080203224003] 
[Fixed warnings in deSugar/DsExpr, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203214848] 
[Fixed warnings in deSugar/DsGRHSs, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203214602] 
[Fixed warnings in deSugar/DsListComp, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203211253] 
[Fixed warnings in deSugar/Check, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203210814] 
[Fixed warnings in deSugar/Match, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203210533] 
[Fixed warnings in deSugar/MatchCon, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080203210402] 
[Fixed warnings in deSugar/DsMonad
Twan van Laarhoven <twanvl@gmail.com>**20080203210339] 
[Wibble the Makefile: DQ, \" and '"'
Ian Lynagh <igloo@earth.li>**20080210171104] 
[Don't use -w when compiling Config.hs
Ian Lynagh <igloo@earth.li>**20080210171050] 
[Add typesigs to Config.hs
Ian Lynagh <igloo@earth.li>**20080210170925] 
[Allow skipping "make clean" or only re-running the testsuite in validate
Ian Lynagh <igloo@earth.li>**20080210162842] 
[Mac installer: added support for full docs
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080209110727] 
[Fixed permissions and other cleanup in Mac installer package
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080207030528] 
[Adjust error message (Trac #2079)
simonpj@microsoft.com**20080207171622] 
[Redo inlining patch, plus some tidying up
simonpj@microsoft.com**20080207155102
 
 This adds back in the patch 
   * UNDO: Be a little keener to inline
 
 It originally broke the compiler because it tickled a Cmm optimisation bug,
 now fixed.  
 
 In revisiting this I have also make inlining a bit cleverer, in response to
 more examples from Roman. In particular
 
   * CoreUnfold.CallCtxt is a data type that tells something about
     the context of a call.  The new feature is that if the context is
     the argument position of a function call, we record both 
        - whether the function (or some higher up function) has rules
        - what the argument discount in that position is
     Either of these make functions keener to inline, even if it's
     in a lazy position
 
   * There was conseqential tidying up on the data type of CallCont.
     In particular I got rid of the now-unused LetRhsFlag
 
 
 
] 
[Comments, and a type signature
simonpj@microsoft.com**20080125174203] 
[FIX #2080: an optimisation to remove a widening was wrong
Simon Marlow <simonmar@microsoft.com>**20080208124219] 
[Remove some of the old compat stuff now that we assume GHC 6.4
Simon Marlow <simonmar@microsoft.com>**20080208124132] 
[Allow runghc to take input from stdin, just like Ruby & Python
Simon Marlow <simonmar@microsoft.com>**20080207145830] 
[remove a bogus assertion
Simon Marlow <simonmar@microsoft.com>**20080207143805] 
[Convert more UniqFM's back to LazyUniqFM's
Ian Lynagh <igloo@earth.li>**20080207144736
 These fix these failures:
    break008(ghci)
    break009(ghci)
    break026(ghci)
    ghci.prog009(ghci)
    ghci025(ghci)
    print007(ghci)
    prog001(ghci)
    prog002(ghci)
    prog003(ghci)
 at least some of which have this symptom:
     Exception: expectJust prune
] 
[Be a bit more consistent about what's a set and what's a map
Ian Lynagh <igloo@earth.li>**20080205211909] 
[Make some more modules use LazyUniqFM instead of UniqFM
Ian Lynagh <igloo@earth.li>**20080207015714
 If these modules use UniqFM then we get a stack overflow when compiling
 modules that use fundeps. I haven't tracked down the actual cause.
] 
[Remove unused import
Ian Lynagh <igloo@earth.li>**20080207002544] 
[Make UniqFM strict in its elements
Ian Lynagh <igloo@earth.li>**20080206141620] 
[Use uniqSetToList rather than eltsUFM
Ian Lynagh <igloo@earth.li>**20080206000043] 
[Use isEmptyUniqSet rather than isNullUFM
Ian Lynagh <igloo@earth.li>**20080205205336] 
[Added Uninstaller
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080206073054] 
[FIX BUILD on x86_64
Simon Marlow <simonmar@microsoft.com>**20080206113936] 
[matchesPkg: match against the pkg Id (foo-1.0) not just the package name (foo)
Simon Marlow <simonmar@microsoft.com>**20080205090429
 Fixes the ghcpkg01 test.
] 
[Teach cheapEqExpr about casts
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080206035007
 
 Previously, cheapEqExpr would always return False if it encountered a cast.
 This was bad for two reasons. Firstly, CSE (which uses cheapEqExpr to compare
 expressions) never eliminated expressions which contained casts and secondly,
 it was inconsistent with exprIsBig. This patch fixes this.
] 
[Inject implicit bindings before the simplifier (Trac #2070)
simonpj@microsoft.com**20080205165507
 
 With constructor unpacking, it's possible for constructors and record
 selectors to have non-trivial code, which should be optimised before
 being fed to the code generator.  Example:
 
   data Foo = Foo { get :: {-# UNPACK #-} !Int }
 
 Then we do not want to get this:
   T2070.get =
     \ (tpl_B1 :: T2070.Foo) ->
     case tpl_B1 of tpl1_B2 { T2070.Foo rb_B4 ->
         let {
           ipv_B3 [Just S] :: GHC.Base.Int
           [Str: DmdType m]
           ipv_B3 = GHC.Base.I# rb_B4
         } in  ipv_B3 }
 
 If this goes through to codegen, we'll generate bad code.  Admittedly,
 this only matters when the selector is used in a curried way (e.g
 map get xs), but nevertheless it's silly.
 
 This patch injects the implicit bindings in SimplCore, before the
 simplifier runs.  That slows the simplifier a little, because it has
 to look at some extra bindings; but it's probably a slight effect.
 If it turns out to matter I suppose we can always inject them later,
 e.g. just before the final simplification.
 
 An unexpected (to me) consequence is that we get some specialisation rules
 for class-method selectors.  E.g. we get a rule
        RULE  (==) Int dInt = eqInt
 There's no harm in this, but not much benefit either, because the 
 same result will happen when we inline (==) and dInt, but it's perhaps
 more direct.
 
 
] 
[Make do-notation a bit more flexible (Trac #1537)
simonpj@microsoft.com**20080205164816
 
 This is a second attempt to fix #1537: to make the static typechecking
 of do-notation behave just like the desugared version of the same thing.
 This should allow parameterised monads to work properly (see Oleg's comment
 in the above ticket).
 
 We can probably merge to 6.8.3 if it goes smoothly.
 
 Incidentally, the resulting setup suffers from greater type ambiguity
 if (>>=) has a very general type.  So test rebindable6 no longer works
 (at least not without more type signatures), and rebindable5 requires
 extra functional dependencies.  But they are weird tests.
 
] 
[White space only
simonpj@microsoft.com**20080205163702] 
[FIX #2047: Windows (and older Unixes): align info tables to 4 bytes, not 2
Simon Marlow <simonmar@microsoft.com>**20080205101425
 Perhaps in the past '.align 2' meant align to 4 bytes, but nowadays it
 means align to 2 bytes.  The compacting collector requires info tables
 to be aligned to 4 bytes, because it stores tag bits in the low 2
 bits.
 
 This only affects -fvia-C - the native code generator was already
 emitting the correct alignment.  The incorrect alignment might well
 have been adversely affecting performance with -fvia-C on Windows.
] 
[Most of installer for framework on system volume
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080205073738] 
[Split into two types of Mac installer specs
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080205052504] 
[Lambda logo for packages
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080205052017
 - This image is in the public domain, cf 
   http://en.wikipedia.org/wiki/Image:Greek_lc_lamda_thin.svg
] 
[xcode build target for fixed /Library/Frameworks inst
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080205030047
 - Also moving all MacOS-specific Makefile components into 
   distrib/MacOS/Makefile
] 
[First stab at an installer package for the Mac
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080202134853
 - GHC as a Mac framework
 - I tried to make a package where the user could choose whether to install
   in /Library/Frameworks or ~/Library/Frameworks (to allow installation for
   non-admins).  However, that doesn't work well without including the whole
   distribution twice as the decision as to whether the admin password needs
   to be entered is made at packaging time (not at install time).
] 
[Support for using libffi to implement FFI calls in GHCi (#631)
Simon Marlow <simonmar@microsoft.com>**20080204161053
 This means that an unregisterised build on a platform not directly
 supported by GHC can now have full FFI support using libffi.
 
 Also in this commit:
 
  - use PrimRep rather than CgRep to describe FFI args in the byte
    code generator.  No functional changes, but PrimRep is more correct.
 
  - change TyCon.sizeofPrimRep to primRepSizeW, which is more useful
] 
[Use the correct libffi type for pointers
Simon Marlow <simonmar@microsoft.com>**20080104131936] 
[Fix DEBUG build
simonpj@microsoft.com**20080204160514] 
[Make seqAlts actually seq everything
Ian Lynagh <igloo@earth.li>**20080203134321] 
[Strictness tweaks
Ian Lynagh <igloo@earth.li>**20080203024836] 
[Whitespace
Ian Lynagh <igloo@earth.li>**20080203003929] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080202213936] 
[Tweak strictness
Ian Lynagh <igloo@earth.li>**20080202213542] 
[Fix warnings in deSugar/DsBinds
Ian Lynagh <igloo@earth.li>**20080130144014] 
[UNDO: Be a little keener to inline
Simon Marlow <simonmar@microsoft.com>**20080201144810
 
 This patch caused at least the following test failures:
    1744(normal)
    ghci028(ghci)
    unicode001(normal)
 and additionally made the stage3 build fail.  
 
 A little more validation please!
 
 I didn't find the exact cause of the failure yet, but it appears that
 the Lexer is miscompiled in some strange way.  If any of {Encoding,
 StringBuffer, or Lexer} are compiled without -O, the problem goes
 away.
] 
[FIX BUILD with GHC 6.4.x
Simon Marlow <simonmar@microsoft.com>**20080201122753] 
[FIX BUILD with ghc-6.4.x
Simon Marlow <simonmar@microsoft.com>**20080201114302] 
[Some tweaks to the building from source section
Simon Marlow <simonmar@microsoft.com>**20080129091132] 
[Warning clean up
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080131024845] 
[Move spiltDmdTy within module (no change in code)
simonpj@microsoft.com**20080129011438] 
[Fix typo where I forgot the new substitution
simonpj@microsoft.com**20080128213856] 
[Add missing (error) case in isIrrefutablePat
simonpj@microsoft.com**20080128213429] 
[Add missing (error) case in pprConDecl
simonpj@microsoft.com**20080128213409] 
[Fix warnings on non-Windows
Ian Lynagh <igloo@earth.li>**20080130114640] 
[Fixed warnings in main/ErrUtils
Twan van Laarhoven <twanvl@gmail.com>**20080127015419] 
[Fixed warnings in main/HeaderInfo, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080127014118] 
[Fixed warnings in main/DynFlags
Twan van Laarhoven <twanvl@gmail.com>**20080127012443] 
[Fixed warnings in hsSyn/HsSyn
Twan van Laarhoven <twanvl@gmail.com>**20080127004626] 
[Fixed warnings in hsSyn/HsUtils
Twan van Laarhoven <twanvl@gmail.com>**20080127004506] 
[Fixed warnings in hsSyn/HsTypes
Twan van Laarhoven <twanvl@gmail.com>**20080127004419] 
[Fixed warnings in hsSyn/HsDoc
Twan van Laarhoven <twanvl@gmail.com>**20080127004359] 
[Fixed warnings in hsSyn/HsLit
Twan van Laarhoven <twanvl@gmail.com>**20080127004330] 
[Fixed warnings in hsSyn/HsImpExp, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080127004254] 
[Fixed warnings in hsSyn/HsPat, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080127004209] 
[Fixed warnings in hsSyn/HsBinds, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080127004119] 
[Fixed warnings in hsSyn/HsDecls, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080127004046] 
[Fixed warnings in simplCore/CSE
Twan van Laarhoven <twanvl@gmail.com>**20080126233918] 
[Fixed warnings in profiling/CostCentre, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126232841] 
[Fixed warnings in types/InstEnv
Twan van Laarhoven <twanvl@gmail.com>**20080126231732] 
[Fixed warnings in types/FamInstEnv
Twan van Laarhoven <twanvl@gmail.com>**20080126231426] 
[Fixed warnings in simplStg/SRT, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126230900] 
[Fixed warnings in simplStg/StgStats, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126230830] 
[Fixed warnings in simplStg/SimplStg
Twan van Laarhoven <twanvl@gmail.com>**20080126230805] 
[Fixed warnings in vectorise/VectUtils
Twan van Laarhoven <twanvl@gmail.com>**20080126223033] 
[Fixed warnings in types/Generics
Twan van Laarhoven <twanvl@gmail.com>**20080126222817] 
[Fixed warnings in stgSyn/StgSyn
Twan van Laarhoven <twanvl@gmail.com>**20080126221010] 
[Fixed warnings in types/TyCon
Twan van Laarhoven <twanvl@gmail.com>**20080126215800] 
[Fixed warnings in types/Type, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126214126] 
[Fixed warnings in types/TypeRep
Twan van Laarhoven <twanvl@gmail.com>**20080126211722] 
[Fixed warnings in types/FunDeps
Twan van Laarhoven <twanvl@gmail.com>**20080126203050] 
[Fixed warnings in basicTypes/OccName
Twan van Laarhoven <twanvl@gmail.com>**20080126202737] 
[Fixed warnings in basicTypes/RdrName
Twan van Laarhoven <twanvl@gmail.com>**20080126202104] 
[Fixed warnings in utils/Encoding
Twan van Laarhoven <twanvl@gmail.com>**20080126201235] 
[Fixed warnings in utils/Digraph
Twan van Laarhoven <twanvl@gmail.com>**20080126200754] 
[Fixed warnings in basicTypes/Demand
Twan van Laarhoven <twanvl@gmail.com>**20080126195929] 
[Fixed warnings in basicTypes/Unique
Twan van Laarhoven <twanvl@gmail.com>**20080126195459] 
[Fixed warnings in coreSyn/ExternalCore
Twan van Laarhoven <twanvl@gmail.com>**20080126194759] 
[Fixed warnings in simplCore/OccurAnal
Twan van Laarhoven <twanvl@gmail.com>**20080126194426] 
[Fixed warnings in basicTypes/BasicTypes
Twan van Laarhoven <twanvl@gmail.com>**20080126194255] 
[Fixed warnings in basicTypes/Literal, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126193209] 
[Fixed warnings in basicTypes/Id
Twan van Laarhoven <twanvl@gmail.com>**20080126192817] 
[Fixed warnings in basicTypes/Var
Twan van Laarhoven <twanvl@gmail.com>**20080126191939] 
[Fixed warnings in basicTypes/Name
Twan van Laarhoven <twanvl@gmail.com>**20080126191501] 
[Fixed warnings in types/Coercion, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126190735] 
[Fixed warnings in coreSyn/MkExternalCore, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080126012807] 
[Fixed warnings in coreSyn/PprExternalCore
Twan van Laarhoven <twanvl@gmail.com>**20080125162418] 
[Fixed warnings in coreSyn/CoreUtils, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080125161800] 
[Fixed warnings in coreSyn/CoreUnfold
Twan van Laarhoven <twanvl@gmail.com>**20080125161308] 
[Fixed warnings in coreSyn/CorePrep
Twan van Laarhoven <twanvl@gmail.com>**20080125161051] 
[Fixed warnings in coreSyn/CoreSubst
Twan van Laarhoven <twanvl@gmail.com>**20080125161002] 
[Fixed warnings in coreSyn/CoreLint
Twan van Laarhoven <twanvl@gmail.com>**20080125160809] 
[Fixed warnings in coreSyn/CoreFVs, except for incomplete pattern matches
Twan van Laarhoven <twanvl@gmail.com>**20080125160716] 
[Fixed warnings in types/Class
Twan van Laarhoven <twanvl@gmail.com>**20080125160438] 
[Fix warnings in coreSyn/CoreTidy
Twan van Laarhoven <twanvl@gmail.com>**20080118165559] 
[Fix warnings in coreSyn/CoreSyn
Twan van Laarhoven <twanvl@gmail.com>**20080118165506] 
[Strictness tweaks
Ian Lynagh <igloo@earth.li>**20080125174347] 
[Parser tweak
Ian Lynagh <igloo@earth.li>**20080125145847] 
[A couple more parser tweaks
Ian Lynagh <igloo@earth.li>**20080125143421] 
[Make comb[234] strict
Ian Lynagh <igloo@earth.li>**20080124183149] 
[Strictness tweaks
Ian Lynagh <igloo@earth.li>**20080124183142] 
[Tell happy to be strict
Ian Lynagh <igloo@earth.li>**20080124165214] 
[Make the Parser Monad's return strict
Ian Lynagh <igloo@earth.li>**20080124155827] 
[Get a bit of sharing
Ian Lynagh <igloo@earth.li>**20080124152000] 
[Make sL strict in /both/ arguments to L
Ian Lynagh <igloo@earth.li>**20080124151223] 
[A touch more strictness in the parser
Ian Lynagh <igloo@earth.li>**20080124150137] 
[Add a bit of strictness to the parser
Ian Lynagh <igloo@earth.li>**20080124145311] 
[Use nilFS
Ian Lynagh <igloo@earth.li>**20080123211917] 
[Whitespace only
Ian Lynagh <igloo@earth.li>**20080123174153] 
[Fix #2062: foldr1 problem in hpc tool
andy@galois.com**20080126210607] 
[Fix do-notation so that it works with -DDEBUG
simonpj@microsoft.com**20080125163101] 
[Be a little keener to inline
simonpj@microsoft.com**20080125104616
 
 This is really a bug.  A saturated call in an "interesting" context
 should inline, but there was a strange "n_val_args > 0" condition, which
 was stopping it.  Reported by Roman.
 
 
] 
[Fix the build
Ian Lynagh <igloo@earth.li>**20080124141800
 Work around various problems caused by some of the monadification patches
 not being applied.
] 
[Replace ioToTcRn with liftIO
Twan van Laarhoven <twanvl@gmail.com>**20080117220553] 
[Remove unused custom versions of monad combinators from IOEnv
Twan van Laarhoven <twanvl@gmail.com>**20080117215835] 
[Remove unused custom versions of monad combinators from UniqSupply
Twan van Laarhoven <twanvl@gmail.com>**20080117215752] 
[Replace remaining uses of ioToIOEnv by liftIO, remove ioToIOEnv
Twan van Laarhoven <twanvl@gmail.com>**20080117215233] 
[Monadify iface/BuildTyCl: use return
Twan van Laarhoven <twanvl@gmail.com>**20080117215036] 
[Monadify iface/TcIface: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117214938] 
[Monadify iface/MkIface: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117214441] 
[Monadify iface/LoadIface: use return and liftIO
Twan van Laarhoven <twanvl@gmail.com>**20080117214233] 
[Monadify iface/IfaceEnv: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117214041] 
[Monadify typecheck/TcRnMonad: use return, standard monad functions and liftIO
Twan van Laarhoven <twanvl@gmail.com>**20080117213850] 
[Monadify typecheck/TcEnv: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117213636] 
[Monadify typecheck/TcRnDriver: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117213352] 
[Monadify typecheck/TcMatches: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117213307] 
[Monadify typecheck/TcMType: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117213242] 
[Monadify typecheck/TcInstDcls: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117213040] 
[Monadify typecheck/TcHsType: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117212822] 
[Monadify typecheck/TcSimplify: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117212200] 
[Monadify typecheck/TcSplice: use do and return
Twan van Laarhoven <twanvl@gmail.com>**20080117211911] 
[Monadify typecheck/TcTyClsDecls: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117211746] 
[Monadify typecheck/TcDefaults: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117211558] 
[Monadify typecheck/TcDeriv: use return
Twan van Laarhoven <twanvl@gmail.com>**20080117211507] 
[Monadify typecheck/TcClassDcl: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117211439] 
[Monadify typecheck/TcBinds: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117211035] 
[Monadify typecheck/TcArrows: use do and return
Twan van Laarhoven <twanvl@gmail.com>**20080117210818] 
[Monadify typecheck/Inst: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117210655] 
[Monadify typecheck/TcUnify: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117210213
   there may be some accidental tab->space conversion
] 
[Monadify typecheck/TcTyFuns: use standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117205505] 
[Monadify typecheck/TcPat: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117205423] 
[Monadify typecheck/TcRules: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117205307] 
[Monadify typecheck/TcForeign: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117204934] 
[Monadify typecheck/TcExpr: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117204603] 
[Monadify specialise/Specialise: use do, return, standard monad functions and MonadUnique
Twan van Laarhoven <twanvl@gmail.com>**20080117204330] 
[Monadify specialise/SpecConstr: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117203842] 
[Monadify stgSyn/StgLint
Twan van Laarhoven <twanvl@gmail.com>**20080117203042
  - made LintM a newtype instead of a type synonym
  - use do, return and standard monad functions
  - use MaybeT where `thenMaybeL` was used
  - removed custom versions of monad functions
 
] 
[Monadify stgSyn/CoreToStg
Twan van Laarhoven <twanvl@gmail.com>**20080117202619
  - made LneM a newtype instead of a type synonym
  - use do, return and standard monad functions
  - removed custom versions of monad functions
] 
[Remove generic monad function from State, it was moved to MonadUtils
Twan van Laarhoven <twanvl@gmail.com>**20080117202144] 
[Added MaybeT monad transformer to utils/Maybes
Twan van Laarhoven <twanvl@gmail.com>**20080117202051] 
[Removed unused Maybe functions, use the standard Maybe monad instead
Twan van Laarhoven <twanvl@gmail.com>**20080117201953] 
[MonadIO instance for IOEnv
Twan van Laarhoven <twanvl@gmail.com>**20080117201812] 
[Monadify simplCore/SimplMonad: custom monad functions are no longer needed
Twan van Laarhoven <twanvl@gmail.com>**20080117200354] 
[Monadify simplCore/SimplMonad: use MonadUnique instance instead of custom functions
Twan van Laarhoven <twanvl@gmail.com>**20080117200228] 
[Monadify simplCore/SetLevels: use do, return, standard monad functions and MonadUnique
Twan van Laarhoven <twanvl@gmail.com>**20080117195958] 
[Monadify simplCore/SimplUtils: use do, return, standard monad functions and MonadUnique
Twan van Laarhoven <twanvl@gmail.com>**20080117195625] 
[Monadify simplCore/Simplify: use do and return
Twan van Laarhoven <twanvl@gmail.com>**20080117195408] 
[Monadify simplCore/SimplEnv: use standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117195255] 
[Monadify simplCore/SimplCore: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117195149] 
[Monadify profiling/SCCfinal
Twan van Laarhoven <twanvl@gmail.com>**20080117194417
   - change monad type synonym into a newtype
   - use do, return and standard monad functions
] 
[Monadify coreSyn/CorePrep: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117193154] 
[Monadify rename/RnTypes: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117190823] 
[Monadify rename/RnPat: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117190033] 
[Monadify rename/RnNames: use return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117185837] 
[seqMaybe is more commonly known as mplus
Twan van Laarhoven <twanvl@gmail.com>**20080117185330] 
[Monadify rename/RnBinds: use do, return and standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117184354] 
[Monadify stranal/StrictAnal: use the State monad instead of a custom thing
Twan van Laarhoven <twanvl@gmail.com>**20080117180449] 
[Monadify stranal/WwLib: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117180022] 
[Added MonadUnique class for monads that have a unique supply
Twan van Laarhoven <twanvl@gmail.com>**20080117175616] 
[Monadify stranal/WorkWrap: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117175007] 
[Added Applicative and Functor instances for State monad
Twan van Laarhoven <twanvl@gmail.com>**20080117174656] 
[Monadify deSugar/DsMonad: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117174432] 
[Monadify deSugar/Desugar: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117174130] 
[Monadify deSugar/DsUtils: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117173856] 
[Monadify deSugar/DsListComp: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117173205] 
[Monadify deSugar/DsForeign: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117172843] 
[Monadify deSugar/DsGRHSs: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117172228] 
[Monadify deSugar/DsExpr: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117164055] 
[Added Applicative instance for IOEnv
Twan van Laarhoven <twanvl@gmail.com>**20080117162644] 
[Add 'util/MonadUtils.hs' with common monad (and applicative) combinators
Twan van Laarhoven <twanvl@gmail.com>**20080117161939] 
[Monadify deSugar/MatchLit: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117173439] 
[Monadify deSugar/Match: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117173336] 
[Monadify deSugar/DsCCall: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117165334] 
[Monadify deSugar/DsArrows: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117165114] 
[Monadify deSugar/DsBinds: use do, return, applicative, standard monad functions
Twan van Laarhoven <twanvl@gmail.com>**20080117164746] 
[Added MASSERT macro for assertions in do notation
Twan van Laarhoven <twanvl@gmail.com>**20080117163112] 
[FIX BUILD wrong imports on non-Windows
Simon Marlow <simonmar@microsoft.com>**20080124092935] 
[Show CmdLineError exceptions as "<command line>: ..."
Simon Marlow <simonmar@microsoft.com>**20080123163145
 instead of something like "ghc-6.8.2: ...", which causes problems in
 the test suite.  In any case, "<command line>" seems a more
 appropriate context for these errors, the only question is whether
 we're using CmdLineError incorrectly anywhere.
] 
[FIX #1750: in isBrokenPackage, don't loop if the deps are recursive
Simon Marlow <simonmar@microsoft.com>**20080123160703] 
[FIX #1750: throw out mutually recursive groups of packages
Simon Marlow <simonmar@microsoft.com>**20080123160635] 
[Windows now doesn't need different values for DQ in the build system
Ian Lynagh <igloo@earth.li>**20080123173933] 
[Fix setting argv[0] in shell-utils.c on Windows
Ian Lynagh <igloo@earth.li>**20080123160139] 
[Escape arguments for Windows in shell-tools.c
Ian Lynagh <igloo@earth.li>**20080123151724] 
[Attach the INLINE Activation pragma to any automatically-generated specialisations
simonpj@microsoft.com**20080123134012
 
 Another idea suggested by Roman, happily involving a one-line change.  Here's 
 the new Note in Specialise:
 
 Note [Auto-specialisation and RULES]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider:
    g :: Num a => a -> a
    g = ...
 
    f :: (Int -> Int) -> Int
    f w = ...
    {-# RULE f g = 0 #-}
 
 Suppose that auto-specialisation makes a specialised version of
 g::Int->Int That version won't appear in the LHS of the RULE for f.
 So if the specialisation rule fires too early, the rule for f may
 never fire.
 
 It might be possible to add new rules, to "complete" the rewrite system.
 Thus when adding
        RULE forall d. g Int d = g_spec
 also add
        RULE f g_spec = 0
 
 But that's a bit complicated.  For now we ask the programmer's help,
 by *copying the INLINE activation pragma* to the auto-specialised rule.
 So if g says {-# NOINLINE[2] g #-}, then the auto-spec rule will also
 not be active until phase 2. 
 
] 
[Tidy up the treatment of SPECIALISE pragmas
simonpj@microsoft.com**20080122122613
 
 Remove the now-redundant "const-dicts" field in SpecPrag
 
 In dsBinds, abstract over constant dictionaries in the RULE.
 This avoids the creation of a redundant, duplicate, rule later
 in the Specialise pass, which was happening before.
 
 There should be no effect on performance either way, just less
 duplicated code, and the compiler gets a little simpler.
 
] 
[Comments only
simonpj@microsoft.com**20080122122547] 
[FIX #1838, #1987: change where GHCi searches for config files
Simon Marlow <simonmar@microsoft.com>**20080123143207
 
 6.6 behaviour:
   - ./.ghci
   - $HOME/.ghci
 
 6.8.[12] behaviour:
   - ./.ghci
   - Windows: c:/Documents and Settings/<user>/.ghci
   - Unix: $HOME/.ghci
 
 6.10 (and 6.8.3 when this is merged):
   - ./.ghci
   - Windows: c:/Documents and Settings/<user>/Application Data/ghc/ghci.conf
   - Unix: $HOME/.ghc/ghci.conf
   - $HOME/.ghci
 
 We will need to document this in the 6.8.3 release notes because it
 may affect Windows users who have adapted their setup to 6.8.[12].
] 
[FIX #1767 :show documentation claimed too much
Simon Marlow <simonmar@microsoft.com>**20080122152943
 Also put the :help docs back within 80 columns
] 
[fix syntax-error output for :show
Simon Marlow <simonmar@microsoft.com>**20080122144923] 
[This goes with the patch for #1839, #1463
Simon Marlow <simonmar@microsoft.com>**20080122161811] 
[use pathSeparator instead of '/'
Simon Marlow <simonmar@microsoft.com>**20080122140957] 
[cleanup only
Simon Marlow <simonmar@microsoft.com>**20080122132047] 
[FIX #1839, #1463, by supporting ghc-pkg bulk queries with substring matching
claus.reinke@talk21.com**20080121161744
 
    - #1839 asks for a ghc-pkg dump feature, #1463 for the ability
      to query the same fields in several packages at once.
 
    - this patch enables substring matching for packages in 'list',
      'describe', and 'field', and for modules in find-module. it
      also allows for comma-separated multiple fields in 'field'.
      substring matching can optionally ignore cases to avoid the
      rather unpredictable capitalisation of packages.
 
    - the patch is not quite as full-featured as the one attached
      to #1839, but avoids the additional dependency on regexps.
      open ended substrings are indicated by '*' (only the three
      forms prefix*, *suffix, *infix* are supported)
 
    - on windows, the use of '*' for package/module name globbing
      leads to conflicts with filename globbing: by default, windows
      programs are self-globbing, and bash adds another level of
      globbing on top of that. it seems impossible to escape '*'
      from both levels of globbing, so we disable default globbing
      for ghc-pkg and ghc-pkg-inplace. users of bash will still
      have filename globbing available, users of cmd won't.
 
    - if it is considered necessary to reenable filename globbing
      for cmd users, it should be done selectively, only for
      filename parameters. to this end, the patch includes a
      glob.hs program which simply echoes its parameters after
      filename globbing. see the commented out glob command in
      Main.hs for usage or testing.
 
    - this covers both tickets, and permits for the most common
      query patterns (finding all packages contributing to the
      System. hierarchy, finding all regex or string packages,
      listing all package maintainers or haddock directories,
      ..), which not only i have wanted to have for a long time.
 
      examples (the quotes are needed to escape shell-based
      filename globbing and should be omitted in cmd.exe):
 
        ghc-pkg list '*regex*' --ignore-case
        ghc-pkg list '*string*' --ignore-case
        ghc-pkg list '*gl*' --ignore-case
        ghc-pkg find-module 'Data.*'
        ghc-pkg find-module '*Monad*'
        ghc-pkg field '*' name,maintainer
        ghc-pkg field '*' haddock-html
        ghc-pkg describe '*'
 
 
] 
[Wibble to the OccurAnal fix for RULEs and loop-breakers
simonpj@microsoft.com**20080121165529] 
[FIX #2049, another problem with the module context on :reload
Simon Marlow <simonmar@microsoft.com>**20080121145935
 The previous attempt to fix this (#1873, #1360) left a problem that
 occurred when the first :load of the program failed (#2049).  
 
 Now I've implemented a different strategy: between :loads, we remember
 all the :module commands, and just replay them after a :reload.  This
 is in addition to remembering all the package modules added with
 :module, which is orthogonal.
 
 This approach is simpler than the previous one, and seems to do the
 right thing in all the cases I could think of.  Let's hope this is the
 last bug in this series...
] 
[Increase the bar for bootstrapping GHC to 6.4 (HEAD only)
Simon Marlow <simonmar@microsoft.com>**20080121111835
  - remove $(ghc_ge_601), $(ghc_ge_602), $(ghc_ge_603)
  - configure now checks the GHC version number
  - there are probably various cleanups that we can now do in compat/
    and compiler/, but I haven't done those yet.
] 
[Do not worker/wrapper INLINE things, even if they are in a recursive group
simonpj@microsoft.com**20080121135909
 
 This patch stops the worker/wrapper transform working on an INLINE thing,
 even if it's in a recursive group.  It might not be the loop breaker.  Indeed
 a recursive group might have no loop breaker, if the only recursion is 
 through rules.
 
 Again, this change was provoked by one of Roman's NDP libraries.
 Specifically the Rec { splitD, splitJoinD } group in 
        Data.Array.Parallel.Unlifted.Distributed.Arrays
 
 Simon
 
] 
[Make the loop-breaking algorithm a bit more liberal, where RULES are involved
simonpj@microsoft.com**20080121135654
 
 This is another gloss on the now-quite-subtle and heavily-documented algorithm
 for choosing loop breakers.
 
 This fix, provoked by Roman's NDP library, makes sure that when we are choosing
 a loop breaker we only take into account variables free on the *rhs* of a rule
 not the *lhs*.
 
 Most of the new lines are comments!
 
] 
[Fix Trac #2055
simonpj@microsoft.com**20080121124244
 
 Sorry, this was my fault, a consequence of the quasi-quoting patch.  
 
 I've added rn062 as a test.
 
 
] 
[Fix exception message with ghc -e
Ian Lynagh <igloo@earth.li>**20080121104142
 When running with ghc -e, exceptions should claim to be from the program
 that we are running, not ghc.
] 
[Fix warnings in main/CmdLineParser
Ian Lynagh <igloo@earth.li>**20080121103158] 
[Normalise FilePaths before printing them
Ian Lynagh <igloo@earth.li>**20080120193002] 
[Tweak runghc
Ian Lynagh <igloo@earth.li>**20080120184639] 
[Fix catching exit exceptions in ghc -e
Ian Lynagh <igloo@earth.li>**20080120170236] 
[Typo in phase-control documentation
simonpj@microsoft.com**20080121113620] 
[Fix warnings in main/Main
Ian Lynagh <igloo@earth.li>**20080119235914] 
[Support multiple -e flags
Ian Lynagh <igloo@earth.li>**20080119223036] 
[Fix ghc -e :main (it was enqueuing the main function, but not running it)
Ian Lynagh <igloo@earth.li>**20080119220044] 
[Fix whitespace
Ian Lynagh <igloo@earth.li>**20080119212830] 
[Fix giving an error if we are given conflicting mode flags
Ian Lynagh <igloo@earth.li>**20080119212602] 
[Add :run and tweak :main
Ian Lynagh <igloo@earth.li>**20080119164923
 You can now give :main a Haskell [String] as an argument, e.g.
 :main ["foo", "bar"]
 and :run is a variant that takes the name of the function to run.
 Also, :main now obeys the -main-is flag.
] 
[Make MacFrameworks a subdirectory of distrib, since it isn't used in the normal building process.
judah.jacobson@gmail.com**20071217235735] 
[Add scripts for building GMP.framework and GNUreadline.framework (OS X).
judah.jacobson@gmail.com**20071127072951] 
[Use -framework-path flags during the cc phase.  Fixes trac #1975.
judah.jacobson@gmail.com**20071212201245] 
[FIX #1821 (Parser or lexer mess-up)
df@dfranke.us**20071210230649] 
[Improve the error when :list can't find any code to show
Ian Lynagh <igloo@earth.li>**20080118225655] 
[Fix imports when !DEBUG
Ian Lynagh <igloo@earth.li>**20080118180126] 
[Tweak the splitter
Ian Lynagh <igloo@earth.li>**20080116195612
 We were generating a label ".LnLC7", which the splitter was confusing
 with a literal constant (LC). The end result was the assembler tripping
 up on ".Ln.text".
] 
[Wibble to SetLevels.abstractVars
simonpj@microsoft.com**20080118171754
 
 I've gotten this wrong more than once.  Hopefully this has it nailed.
 The issue is that in float-out we must abstract over the correct
 variables.
 
 
] 
[Add quasi-quotation, courtesy of Geoffrey Mainland
simonpj@microsoft.com**20080118145503
 
 This patch adds quasi-quotation, as described in
   "Nice to be Quoted: Quasiquoting for Haskell"
        (Geoffrey Mainland, Haskell Workshop 2007)
 Implemented by Geoffrey and polished by Simon.
 
 Overview
 ~~~~~~~~
 The syntax for quasiquotation is very similar to the existing
 Template haskell syntax:
        [$q| stuff |]
 where 'q' is the "quoter".  This syntax differs from the paper, by using
 a '$' rather than ':', to avoid clashing with parallel array comprehensions.
  
 The "quoter" is a value of type Language.Haskell.TH.Quote.QuasiQuoter, which
 contains two functions for quoting expressions and patterns, respectively.
  
      quote = Language.Haskell.TH.Quote.QuasiQuoter quoteExp quotePat
  
      quoteExp :: String -> Language.Haskell.TH.ExpQ
      quotePat :: String -> Language.Haskell.TH.PatQ
 
 TEXT is passed unmodified to the quoter. The context of the
 quasiquotation statement determines which of the two quoters is
 called: if the quasiquotation occurs in an expression context,
 quoteExp is called, and if it occurs in a pattern context, quotePat
 is called.
 
 The result of running the quoter on its arguments is spliced into
 the program using Template Haskell's existing mechanisms for
 splicing in code. Note that although Template Haskell does not
 support pattern brackets, with this patch binding occurrences of
 variables in patterns are supported. Quoters must also obey the same
 stage restrictions as Template Haskell; in particular, in this
 example quote may not be defined in the module where it is used as a
 quasiquoter, but must be imported from another module.
 
 Points to notice
 ~~~~~~~~~~~~~~~~
 * The whole thing is enabled with the flag -XQuasiQuotes
 
 * There is an accompanying patch to the template-haskell library. This
   involves one interface change:
        currentModule :: Q String
   is replaced by
        location :: Q Loc
   where Loc is a data type defined in TH.Syntax thus:
       data Loc
         = Loc { loc_filename :: String
              , loc_package  :: String
              , loc_module   :: String
              , loc_start    :: CharPos
              , loc_end      :: CharPos }
 
       type CharPos = (Int, Int)        -- Line and character position
  
   So you get a lot more info from 'location' than from 'currentModule'.
   The location you get is the location of the splice.
   
   This works in Template Haskell too of course, and lets a TH program
   generate much better error messages.
 
 * There's also a new module in the template-haskell package called 
   Language.Haskell.TH.Quote, which contains support code for the
   quasi-quoting feature.
 
 * Quasi-quote splices are run *in the renamer* because they can build 
   *patterns* and hence the renamer needs to see the output of running the
   splice.  This involved a bit of rejigging in the renamer, especially
   concerning the reporting of duplicate or shadowed names.
 
   (In fact I found and removed a few calls to checkDupNames in RnSource 
   that are redundant, becuase top-level duplicate decls are handled in
   RnNames.)
 
 
 
] 
[lots of portability changes (#1405)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20080117011312
 
 re-recording to avoid new conflicts was too hard, so I just put it
 all in one big patch :-(  (besides, some of the changes depended on
 each other.)  Here are what the component patches were:
 
 Fri Dec 28 11:02:55 EST 2007  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * document BreakArray better
 
 Fri Dec 28 11:39:22 EST 2007  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * properly ifdef BreakArray for GHCI
 
 Fri Jan  4 13:50:41 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * change ifs on __GLASGOW_HASKELL__ to account for... (#1405)
   for it not being defined. I assume it being undefined implies
   a compiler with relatively modern libraries but without most
   unportable glasgow extensions.
 
 Fri Jan  4 14:21:21 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * MyEither-->EitherString to allow Haskell98 instance
 
 Fri Jan  4 16:13:29 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * re-portabilize Pretty, and corresponding changes
 
 Fri Jan  4 17:19:55 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * Augment FastTypes to be much more complete
 
 Fri Jan  4 20:14:19 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * use FastFunctions, cleanup FastString slightly
 
 Fri Jan  4 21:00:22 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * Massive de-"#", mostly Int# --> FastInt (#1405)
 
 Fri Jan  4 21:02:49 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * miscellaneous unnecessary-extension-removal
 
 Sat Jan  5 19:30:13 EST 2008  Isaac Dupree <id@isaac.cedarswampstudios.org>
   * add FastFunctions
 
] 
[Add missing extendSubst
simonpj@microsoft.com**20080117180227
 
 Oops -- missed this from previous commit; sorry
 
] 
[Add -fspec-inline-join-points to SpecConstr
simonpj@microsoft.com**20080117150325
 
 This patch addresses a problem that Roman found in SpecConstr.  Consider:
 
 foo :: Maybe Int -> Maybe Int -> Int
 foo a b = let j b = foo a b
            in
            case b of
              Nothing -> ...
              Just n  -> case a of
                           Just m  -> ... j (Just (n+1)) ...
                           Nothing -> ... j (Just (n-1)) ...
 
 We want to make specialised versions for 'foo' for the patterns
        Nothing  (Just v)
        (Just a) (Just b)
 
 Two problems, caused by the join point j.  First, j does not
 scrutinise b, so j won't be specialised f for the (Just v) pattern.
 Second, j is defined where the free var 'a' is not evaluated.
 
 Both are solved by brutally inlining j at its call sites.  This risks
 major code bloat, but it's relatively quick to implement.  The flag
        -fspec-inline-join-points
 causes brutal inlining for a 
        non-recursive binding
        of a function
        whose RHS contains calls
        of a recursive function
 
 The (experimental) flag is static for now, and I have not even
 documented it properly.
 
 
] 
[Fix references to Filepath
Clemens Fruhwirth <clemens@endorphin.org>**20080117134139] 
[Fix egregious error in earlier "Record evaluated-ness" patch
simonpj@microsoft.com**20080117134057] 
[Eliminate warnings with -DDEBUG
simonpj@microsoft.com**20080117124921] 
[Record evaluated-ness information correctly for strict constructors
simonpj@microsoft.com**20080117105256
 
 The add_evals code in Simplify.simplAlt had bit-rotted.  Example:
 
   data T a = T !a
   data U a = U !a
 
   foo :: T a -> U a
   foo (T x) = U x
 
 Here we should not evaluate x before building the U result, because
 the x argument of T is already evaluated.
 
 Thanks to Roman for finding this.
 
 
] 
[In float-out, make sure we abstract over the type variables in the kind of a coercion
simonpj@microsoft.com**20080116153908
 
 I can't remember where this bug showed up, but we were abstracting over a
 coercion variable (co :: a ~ T), without also abstracting over 'a'.
 
 The fix is simple.
 
] 
[Fix broken debug warning
simonpj@microsoft.com**20080116151818] 
[Complain sensibly if you try to use scoped type variables in Template Haskell
simonpj@microsoft.com**20080116151612
 
 This fixes Trac #2024; worth merging onto 6.8 branch.
 
] 
[Comments only
simonpj@microsoft.com**20080116150554] 
[Extra instance for Outputable on 5-tuples
simonpj@microsoft.com**20080116150525] 
[Fix the -frule-check pass
simonpj@microsoft.com**20080116141156
 
 Rules for imported things are now kept in the global rule base, not
 attached to the global Id.  The rule-check pass hadn't kept up.
 
 This should fix it.
 
] 
[Add dyn-wrapper.c used as cross-plattform launch wrapper for executables using dynamic libraries in non-standard places
Clemens Fruhwirth <clemens@endorphin.org>**20080116220603] 
[Use runPhase_MoveBinary also for generating a dynamic library wrapper
Clemens Fruhwirth <clemens@endorphin.org>**20080116220420] 
[Remove -fhardwire-lib-paths in favour of -dynload sysdep
Clemens Fruhwirth <clemens@endorphin.org>**20080110121736] 
[ghc-inplace defaults to -fhardwire-lib-paths. Change that to -dynload wrapped
Clemens Fruhwirth <clemens@endorphin.org>**20080110090839] 
[Add -dynload flag as dynamic flag.
Clemens Fruhwirth <clemens@endorphin.org>**20080116205710] 
[Add a missing import
Ian Lynagh <igloo@earth.li>**20080116174149] 
[Fix Makefile generatin on Windows
Ian Lynagh <igloo@earth.li>**20080116162752] 
[Fix slash direction on Windows with the new filePath code
Ian Lynagh <igloo@earth.li>**20080116154317] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20080116011953] 
[The Core type-matcher should look through PredTypes
simonpj@microsoft.com**20080116145939
 
 The core type-matcher Unify.match was previouly using tcView to expand
 types, because it must treat newtypes as distinct from their representation.
 But that meant that it also treated the PredType {C Int} as distinct from
 its representation type (:TC Int).  And that in turn was causing a rule
 not to fire, because the argument types didn't match up.
 
 For this to happen we need to get a situation where we have
 
   a = :DC blah blah    -- Dictionary
   ....(f a).....
 
 Now a has type (:TC Int), bu the RULE for f expects an argument 
 of type {C Int}.  Roman found that just this was happening.
 
 
 
 
] 
[A bottoming function should have infinite arity
simonpj@microsoft.com**20080116145722
 
 I can't think how this one escaped for so long, but
        (error "foo") 
 should have arityType ABot, just as 'error' itself does.
 
 This improves eta expansion.  I spotted it when looking at the function
 
   Data.Array.Parallel.Arr.BBArr.writeMBB
 
 in the ndp package.
 
 
] 
[Add Main.dyn_o deployed into the RTS library dir to linking (see DLLNOTES for rational)
Clemens Fruhwirth <clemens@endorphin.org>**20080110091217] 
[Refactor cross-plattform process spawning from ghc-inplace into shell-tools.c
Clemens Fruhwirth <clemens@endorphin.org>**20080110090721] 
[More verbose error reporting in mk/target.mk
Clemens Fruhwirth <clemens@endorphin.org>**20071231170715] 
[Fix generating dependencies for different ways now we use FilePath
Ian Lynagh <igloo@earth.li>**20080115204716
 We were making filenames like
 dist/build/GHC/Base.p_.o
 rather than
 dist/build/GHC/Base.p_o
] 
[Fix utils/Util for debug build
mainland@eecs.harvard.edu**20080114190530] 
[Give an error if view pattern syntax is used in an expression; fixes #2033
Ian Lynagh <igloo@earth.li>**20080114115031] 
[FIX BUILD (Solaris): include fcntl.h for file operations
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080115051844] 
[Fix warning when USE_READLINE is unset
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20080115015014] 
[Remove an extra ) that was breaking the build on Windows
Ian Lynagh <igloo@earth.li>**20080114103953] 
[Fix warnings in utils/ListSetOps
Ian Lynagh <igloo@earth.li>**20080113150017] 
[Fix warnings in utils/Panic
Ian Lynagh <igloo@earth.li>**20080113142939] 
[Fix warnings in utils/UniqSet
Ian Lynagh <igloo@earth.li>**20080113142604] 
[Fix warnings in utils/Maybes
Ian Lynagh <igloo@earth.li>**20080113142347] 
[Fix warnings in utils/BufWrite
Ian Lynagh <igloo@earth.li>**20080113141630] 
[Fix warnings in utils/FastTypes
Ian Lynagh <igloo@earth.li>**20080113141612
 Split off a FastBool module, to avoid a circular import with Panic
] 
[Fix warnings in utils/OrdList
Ian Lynagh <igloo@earth.li>**20080113132042] 
[Fix warnings in utils/FastMutInt
Ian Lynagh <igloo@earth.li>**20080113131830] 
[Fix warnings in utils/State
Ian Lynagh <igloo@earth.li>**20080113131658] 
[Only initialise readline if we are connected to a terminal
Ian Lynagh <igloo@earth.li>**20080113124107
 Patch from Bertram Felgenhauer <int-e@gmx.de>
] 
[Fix warnings in utils/Util
Ian Lynagh <igloo@earth.li>**20080113005832] 
[Fix warnings in utils/Bag.lhs
Ian Lynagh <igloo@earth.li>**20080113002037] 
[Add GMP_INCLUDE_DIRS in a couple of places
Ian Lynagh <igloo@earth.li>**20080112234215
 Fixes the build on OpenBSD (trac #2009). Based on a patch from kili.
] 
[Tweak whitespace in HsExpr
Ian Lynagh <igloo@earth.li>**20080112185753] 
[Fix warnings in HsExpr
Ian Lynagh <igloo@earth.li>**20080112181444] 
[FilePath fixes
Ian Lynagh <igloo@earth.li>**20080112172837] 
[don't initialize readline needlessly
Ian Lynagh <igloo@earth.li>**20080112155413
 Readline.initialize spills some escape sequences to stdout for some terminal
 types, potentially spoiling  ghc -e  output. So don't initialize readline
 unless we're working interactively on a terminal.
 Patch from Bertram Felgenhauer <int-e@gmx.de>
] 
[Fix whitespace
Ian Lynagh <igloo@earth.li>**20080112155214] 
[Use System.FilePath
Ian Lynagh <igloo@earth.li>**20080112154459] 
[Fix filename completion by adding trailing spaces/slashes manually.
judah.jacobson@gmail.com**20080110221928] 
[Use command-dependent word break characters for tab completion in ghci.  Fixes bug #998.
judah.jacobson@gmail.com**20080109003606] 
[Fix 2030: make -XScopedTypeVariables imply -XRelaxedPolyRec
simonpj@microsoft.com**20080110113133
 
 The type checker doesn't support lexically scoped type variables 
 unless we are using the RelaxedPolyRec option.  Reasons: see
 Note [Scoped tyvars] in TcBinds.
 
 So I've changed DynFlags to add this implication, improved the 
 documentation, and simplified the code in TcBinds somewhat.
 (It's longer but only because of comments!)
  
 
] 
[More refactoring in getCoreToDo
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080109023747] 
[Document -fsimplifier-phases
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080109022822] 
[Add -fsimplifier-phases option
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080109022449
 
 It controls the number of simplifier phases run during optimisation. These are
 numbered from n to 1 (by default, n=2). Phase 0 is always run regardless of
 this flag. The flag is ignored with -O0 since (practically) no optimisation is
 performed in that case.
] 
[Refactor getCoreToDo slightly
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20080109014359] 
[Fix Trac #2018: float-out was ignoring the kind of a coercion variable
simonpj@microsoft.com**20080107142601
 
 The float-out transformation must handle the case where a coercion
 variable is free, which in turn mentions type variables in its kind.
 Just like a term variable really.
 
 I did a bit of refactoring at the same time.
 
 Test is tc241
 
 MERGE to stable branch
 
] 
[Make the treatment of equalities more uniform
simonpj@microsoft.com**20080107142306
 
 This patch (which is part of the fix for Trac #2018) makes coercion variables
 be handled more uniformly.  Generally, they are treated like dictionaries
 in the type checker, not like type variables, but in a couple of places we
 were treating them like type variables.  Also when zonking we should use
 zonkDictBndr not zonkIdBndr.
 
] 
[Fix Trac #2017
simonpj@microsoft.com**20080107125819] 
[Add -XImpredicativeTypes, and tighten up type-validity checking (cf Trac 2019)
simonpj@microsoft.com**20080107115451
 
 Somehow we didn't have a separate flag for impredicativity; now we do.
 
 Furthermore, Trac #2019 showed up a missing test for monotypes in data
 constructor return types.  And I realised that we were even allowing
 things like
        Num (forall a. a) => ...
 which we definitely should not.  
 
 This patch insists on monotypes in several places where we were (wrongly)
 too liberal before.
 
 Could be merged to 6.8 but no big deal.
 
 
] 
[pass -no-user-package-conf to ghc-inplace
Simon Marlow <simonmar@microsoft.com>**20080104162840] 
[Fix build: Recent instance shuffling left us with overlapping instances
Ian Lynagh <igloo@earth.li>**20080106221547] 
[Add instructions for building docs to README
Ian Lynagh <igloo@earth.li>**20080106215723] 
[A little refactoring of GenIfaceEq to make the Outputable instance into H98
simonpj@microsoft.com**20080104105450] 
[Make the instance of DebugNodes more H98-like
simonpj@microsoft.com**20080104105409] 
[change CmmActual, CmmFormal to use a data CmmHinted rather than tuple (#1405)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20080104105339
 This allows the instance of UserOfLocalRegs to be within Haskell98, and IMHO
  makes the code a little cleaner generally.
 This is one small (though tedious) step towards making GHC's code more
  portable...
] 
[generalize instance Outputable GenCmm to H98 (#1405)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071226175915] 
[move and generalize another instance (#1405)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071226174904
 was instance Outputable CmmGraph
 type CmmGraph = LGraph Middle Last
 now instance (ctx) => Outputable (LGraph m l),
 in module with LGraph where it belongs
 This also let us reduce the context of DebugNodes to Haskell98,
 leaving that class's only extension being multi-parameter.
 (also Outputable (LGraph M Last) with M = ExtendWithSpills Middle
 was another redundant instance that was then removed)
] 
[move and generalize an instance (#1405)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071226171913
 UserOfLocalRegs (ZLast Last) isn't Haskell98, but it was just as
 good an instance to be UserOfLocalRegs a => UserOfLocalRegs (ZLast a)
] 
[Do not consult -XGADTs flag when pattern matching on GADTs
simonpj@microsoft.com**20080104125814
 
 See Trac #2004, and Note [Flags and equational constraints] in TcPat.
 
] 
[Add a note about primop wrappers (cf Trac #1509)
simonpj@microsoft.com**20080104125305] 
[Document SOURCE pragma; clarify TH behavior for mutually-recurive modules (Trac #1012)
simonpj@microsoft.com**20080104121939] 
[White space and comments only
simonpj@microsoft.com**20080104102236] 
[Optionally use libffi to implement 'foreign import "wrapper"' (#793)
Simon Marlow <simonmar@microsoft.com>**20080103170236
 To enable this, set UseLibFFI=YES in mk/build.mk.  
 
 The main advantage here is that this reduces the porting effort for
 new platforms: libffi works on more architectures than our current
 adjustor code, and it is probably more heavily tested.  We could
 potentially replace our existing code, but since it is probably faster
 than libffi (just a guess, I'll measure later) and is already working,
 it doesn't seem worthwhile.
 
 Right now, you must have libffi installed on your system.  I used the
 one supplied by Debian/Ubuntu.
] 
[remove trace apparently left in by accident
Simon Marlow <simonmar@microsoft.com>**20080103163805] 
[Remove -funfolding-update-in-place flag documentation
simonpj@microsoft.com**20080103160036
 
 This flag does nothing, and should have been removed ages ago. (GHC
 no longer does update-in-place.)
 
 MERGE to 6.8 branch
 
] 
[Fix warnings with newer gcc versions (I hope)
Simon Marlow <simonmar@microsoft.com>**20080103140338] 
[FIX #1898: add a missing UNTAG_CLOSURE() in checkBlackHoles
Simon Marlow <simonmar@microsoft.com>**20080103112717] 
[fix validation failure on non-i386
Simon Marlow <simonmar@microsoft.com>**20080102151740] 
[expand "out of stack slots" panic to suggest using -fregs-graph, see #1993
Simon Marlow <simonmar@microsoft.com>**20080102150737] 
[Warning clean, and fix compilation with GHC 6.2.x
Simon Marlow <simonmar@microsoft.com>**20080102114529] 
[Add dead code elimination in cmmMiniInline
Simon Marlow <simonmar@microsoft.com>**20071220151734
 cmmMiniInline counts the uses of local variables, so it can easily
 eliminate assigments to unused locals.  This almost never gets
 triggered, as we don't generate any dead assignments, but it will be
 needed by a forthcoming cleanup in CgUtils.emitSwitch.
] 
[implement prefix unboxed tuples (part of #1509)
Isaac Dupree <id@isaac.cedarswampstudios.org>**20080102124001] 
[Link libgmp.a statically into libHSrts.dll on Windows
Clemens Fruhwirth <clemens@endorphin.org>**20080101154017] 
[Embedd DLL name into its import library, so client libs reference them properly in .idata
Clemens Fruhwirth <clemens@endorphin.org>**20080101152157] 
[Add package dependencies to link pass when building ghc package (required for windows DLL build)
Clemens Fruhwirth <clemens@endorphin.org>**20080101152101] 
[Fix building libHSrts.dll by using ghc-pkg instead of grepping in base.cabal
Clemens Fruhwirth <clemens@endorphin.org>**20071230193952] 
[Add installPackage to dependencies of make.library.* as it's used by the rule
Clemens Fruhwirth <clemens@endorphin.org>**20071229162707] 
[Install dynlibs correctly
Clemens Fruhwirth <clemens@endorphin.org>**20071228184024
 
 Add dynlibdir target to config.mk.in, setting it to @libdir@.
 Invoke installPackage with dynlibdir at libraries/Makefile
 Make installPackage.hs hand dynlibdir to Cabal.
] 
[import ord that alex secretly imported
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071228175727] 
[add missing import that happy -agc secretly provided
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071227171335] 
[correct type mistake, hidden by happy -agc coercions!
Isaac Dupree <id@isaac.cedarswampstudios.org>**20071226140743] 
[API changes for cabal-HEAD
Clemens Fruhwirth <clemens@endorphin.org>**20071227143114
 
 Rename interfacedir to haddockdir
 Change empty(Copy|Register)Flags to default(Copy|Register)Flags
 Wrap content of RegisterFlags with toFlag (the Flag type is actually just Maybe)
] 
[Extend API for compiling to and from Core
Tim Chevalier <chevalier@alum.wellesley.edu>**20071225200411
 
 Added API support for compiling Haskell to simplified Core, and for
 compiling Core to machine code. The latter, especially, should be
 considered experimental and has only been given cursory testing. Also
 fixed warnings in DriverPipeline. Merry Christmas.
] 
[When complaining about non-rigid context, give suggestion of adding a signature
simonpj@microsoft.com**20071224122217] 
[Improve handling of newtypes (fixes Trac 1495)
simonpj@microsoft.com**20071221090406
 
 In a few places we want to "look through" newtypes to get to the
 representation type.  But we need to be careful that  we don't fall 
 into an ininite loop with e.g.
        newtype T = MkT T
 
 The old mechansim for doing this was to have a field nt_rep, inside 
 a newtype TyCon, that gave the "ultimate representation" of the type.
 But that failed for Trac 1495, which looked like this:
    newtype Fix a = Fix (a (Fix a))
    data I a = I a
 Then, expanding the type (Fix I) went on for ever.
 
 The right thing to do seems to be to check for loops when epxanding
 the *type*, rather than in the *tycon*.  This patch does that, 
        - Removes nt_rep from TyCon
        - Make Type.repType check for loops
 See Note [Expanding newtypes] in Type.lhs.
 
 At the same time I also fixed a bug for Roman, where newtypes were not
 being expanded properly in FamInstEnv.topNormaliseType.  This function
 and Type.repType share a common structure.
 
 
        Ian, see if this merges easily to the branch
        If not, I don't think it's essential to fix 6.8
 
] 
[Fix Trac #1981: seq on a type-family-typed expression
simonpj@microsoft.com**20071221085542
 
 We were crashing when we saw
        case x of DEFAULT -> rhs
 where x had a type-family type.  This patch fixes it.
 
 MERGE to the 6.8 branch.
 
 
] 
[Comment only
simonpj@microsoft.com**20071220164621] 
[Fix nasty recompilation bug in MkIface.computeChangedOccs
simonpj@microsoft.com**20071220164307
 
        MERGE to 6.8 branch
 
 In computeChangedOccs we look up the old version of a Name.
 But a WiredIn Name doesn't have an old version, because WiredIn things
 don't appear in interface files at all.
 
 Result: ghc-6.9: panic! (the 'impossible' happened)
   (GHC version 6.9 for x86_64-unknown-linux):
        lookupVers1 base:GHC.Prim chr#{v}
 
 This fixes the problem.  The patch should merge easily onto the branch.
 
 
] 
[Fix Trac #1988; keep the ru_fn field of a RULE up to date
simonpj@microsoft.com**20071220131912
 
 The ru_fn field was wrong when we moved RULES from one Id to another.
 The fix is simple enough.
 
 However, looking at this makes me realise that the worker/wrapper stuff
 for recursive newtypes isn't very clever: we generate demand info but
 then don't properly exploit it.  
 
 This patch fixes the crash though.
 
] 
[Add better panic message in getSRTInfo (Trac #1973)
simonpj@microsoft.com**20071220180335] 
[Remove obselete code for update-in-place (which we no longer do)
simonpj@microsoft.com**20071220173432] 
[Implement generalised list comprehensions
simonpj@microsoft.com**20071220111300
 
   This patch implements generalised list comprehensions, as described in 
   the paper "Comprehensive comprehensions" (Peyton Jones & Wadler, Haskell
   Workshop 2007).  If you don't use the new comprehensions, nothing
   should change.
   
   The syntax is not exactly as in the paper; see the user manual entry 
   for details.
   
   You need an accompanying patch to the base library for this stuff 
   to work.
   
   The patch is the work of Max Bolingbroke [batterseapower@hotmail.com], 
   with some advice from Simon PJ.
   
   The related GHC Wiki page is 
     http://hackage.haskell.org/trac/ghc/wiki/SQLLikeComprehensions 
 
] 
[More bindist-publishing fixes and refactoring
Ian Lynagh <igloo@earth.li>**20071218144505] 
[Fix publishing the docs
Ian Lynagh <igloo@earth.li>**20071216122544] 
[FIX #1980: must check for ThreadRelocated in killThread#
Simon Marlow <simonmar@microsoft.com>**20071217164610] 
[Eliminate external GMP dependencies
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20071217093839
 - Ensure the stage1 compiler uses ghc's own GMP library on Mac OS
 - Need to rebuild installPackage and ifBuildable with stage1 compiler as they
   go into bindists
] 
[Include ~/Library/Frameworks in the framework searchpath
Ian Lynagh <igloo@earth.li>**20071217233457
 Patch from Christian Maeder
] 
[Make ghcii.sh executable
Ian Lynagh <igloo@earth.li>**20071217195734] 
[Don't rely on distrib/prep-bin-dist-mingw being executable
Ian Lynagh <igloo@earth.li>**20071217195554] 
[always try to remove the new file before restoring the old one (#1963)
Simon Marlow <simonmar@microsoft.com>**20071214123345] 
[Fix a bug in gen_contents_index
Ian Lynagh <igloo@earth.li>**20071212121154
 The library doc index thought that the docs were in $module.html, rather
 than $package/$module.html.
] 
[Fix lifting of case expressions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071215000837
 
 We have to explicity check for empty arrays in each alternative as recursive
 algorithms wouldn't terminate otherwise.
] 
[Use (UArr Int) instead of PArray_Int# in vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071215000739] 
[Fix bug in VectInfo loading
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071214230914] 
[Remove unused vectorisation built-in
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071214011015] 
[Treat some standard data cons specially during vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213034855
 
 This is a temporary hack which allows us to vectorise literals.
] 
[More vectorisation-related built ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213034839] 
[Track changes to package ndp
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071212062714] 
[Add vectorisation built-ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071212040521] 
[FIX #1963: catch Ctrl-C and clean up properly
Simon Marlow <simonmar@microsoft.com>**20071213154056] 
[Document the new threshold flags
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071214003003] 
[Separate and optional size thresholds for SpecConstr and LiberateCase
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071214002719
 
 This patch replaces -fspec-threshold by -fspec-constr-threshold and
 -fliberate-case-threshold. The thresholds can be disabled by
 -fno-spec-constr-threshold and -fno-liberate-case-threshold.
] 
[Make HscTypes.tyThingId respond not panic on ADataCon
simonpj@microsoft.com**20071204152903] 
[Use Unix format for RnPat (no other change)
simonpj@microsoft.com**20071213140532] 
[Improve free-variable handling for rnPat and friends (fixes Trac #1972)
simonpj@microsoft.com**20071213140213
 
 As well as fixing the immediate problem (Trac #1972) this patch does
 a signficant simplification and refactoring of pattern renaming.
 
 Fewer functions, fewer parameters passed....it's all good.  But it
 took much longer than I expected to figure out.
 
 The most significant change is that the NameMaker type does *binding*
 as well as *making* and, in the matchNameMaker case, checks for unused
 bindings as well.  This is much tider.
 
 (No need to merge to the 6.8 branch, but no harm either.)
 
 
] 
[Allow more than 3 simplifier iterations to be run in phase 0
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213040835
 
 The number of iterations during the first run of phase 0 was erroneously
 hardcoded to 3. It should be *at least* 3 (see comments in code) but can be
 more.
] 
[Document -ddump-simpl-phases
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213040822] 
[New flag: -ddump-simpl-phases
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213040644
 
 This outputs the core after each simplifier phase (i.e., it produces less
 information that -ddump-simpl-iterations).
] 
[Don't dump simplifier iterations with -dverbose-core2core
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071213034635
 
 SimonPJ says this is the correct behaviour. We still have
 -ddump-simpl-iterations.
] 
["list --simple-output" should be quiet when there are no packages to list
Simon Marlow <simonmar@microsoft.com>**20071212102230
 
 Previously:
 
 $ ghc-pkg list --user --simple-output
 ghc-pkg: no matches
 $
 
 Now:
 
 $ ghc-pkg list --user --simple-output
 $
] 
[Fix vectorisation bug
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071206233015] 
[Vectorisation-related built ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071206040829] 
[Teach vectorisation about some temporary conversion functions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071206032547] 
[Vectorise case of unit correctly
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205221305] 
[Teach vectorisation about singletonP
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205221240] 
[Optimise desugaring of parallel array comprehensions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205221213] 
[Teach vectorisation about tuple datacons
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205050221] 
[Track additions to package ndp
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205042649] 
[Track changes to package ndp
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071205033859] 
[Improve pretty-printing of InstDecl
simonpj@microsoft.com**20071210083053
 
 Fixes Trac #1966. 
 
] 
[Comments only
Pepe Iborra <mnislaih@gmail.com>**20071208204815] 
[Refactoring only
Pepe Iborra <mnislaih@gmail.com>**20071208195222
 
 Suspensions in the Term datatype used for RTTI
 always get assigned a Type, so there is no reason
 to juggle around with a (Maybe Type) anymore. 
 
] 
[Change the format used by :print to show the content of references
Pepe Iborra <mnislaih@gmail.com>**20071208193013
     
     This comes as result of the short discussion linked below.
     
     http://www.haskell.org/pipermail/cvs-ghc/2007-December/040049.html
 
] 
[Help the user when she tries to do :history without :trace
Pepe Iborra <mnislaih@gmail.com>**20071208180918
 
 Teach GHCi to show a "perhaps you forgot to use :trace?" when
 it finds that the user is trying to retrieve an empty :history
 
] 
[Prevent the binding of unboxed things by :print
Pepe Iborra <mnislaih@gmail.com>**20071208181830] 
[Coercions from boxy splitters must be sym'ed in pattern matches
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20071208105018] 
[Properly keep track of whether normalising given or wanted dicts
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20071207071302
 - The information of whether given or wanted class dictionaries where
   normalised by rewriting wasn't always correctly propagated in TcTyFuns,
   which lead to malformed dictionary bindings.
 - Also fixes a bug in TcPat.tcConPat where GADT equalities where emitted in
   the wrong position in case bindings (which led to CoreLint failures).
] 
[TcPat.tcConPat uses equalities instead of GADT refinement
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20071120071208
 * This patch implements the use of equality constraints instead of GADT
   refinements that we have been discussing for a while.
 * It just changes TcPat.tcConPat.  It doesn't have any of the simplification
   and dead code removal that is possible due to this change.
 * At the moment, this patch breaks a fair number of GADT regression tests.
] 
[Use installPackage for register --inplace as well as installing
Ian Lynagh <igloo@earth.li>**20071207234652
 We also need to do the GHC.Prim hack when registering inplace or the
 tests that use it fail.
] 
[Fix the libraries Makefile
Ian Lynagh <igloo@earth.li>**20071205125015
     x && y
 is not the same as
     if x; then y; fi
 as the latter doesn't fail when x fails
] 
[Copy hscolour.css into dist/... so it gets installed with the library docs
Ian Lynagh <igloo@earth.li>**20071205013703] 
[Add the hscolour.css from hscolour 1.8
Ian Lynagh <igloo@earth.li>**20071205011733] 
[BIN_DIST_INST_SUBDIR Needs to be defined in config.mk so ./Makefile can see it
Ian Lynagh <igloo@earth.li>**20071207121317] 
[#include ../includes/MachRegs.h rather than just MachRegs.h
Ian Lynagh <igloo@earth.li>**20071205170335
 This fixes building on NixOS. I'm not sure why it worked everywhere else,
 but not on NixOS, before.
] 
[Fix bindist creation: readline/config.mk is gone
Ian Lynagh <igloo@earth.li>**20071203123031] 
[FIX #1843: Generate different instructions on PPC
Ian Lynagh <igloo@earth.li>**20071203123237
 The old ones caused lots of
     unknown scattered relocation type 4
 errors. Patch from Chris Kuklewicz.
] 
[Refactor gen_contents_index
Ian Lynagh <igloo@earth.li>**20071207183538
 Also fixes it with Solaris's sh, spotted by Christian Maeder
] 
[Use GHC.Exts rather than GHC.Prim
Ian Lynagh <igloo@earth.li>**20071202234222] 
[Alter the base:GHC.Prim hack in installPackage, following changes in base
Ian Lynagh <igloo@earth.li>**20071202215719] 
[Remove debug warning, and explain why
simonpj@microsoft.com**20071207170507] 
[comment only
Simon Marlow <simonmar@microsoft.com>**20071206092422] 
[comment typo
Simon Marlow <simonmar@microsoft.com>**20071206092412] 
[add Outputable instance for OccIfaceEq
Simon Marlow <simonmar@microsoft.com>**20071206092403] 
[Workaround for #1959: assume untracked names have changed
Simon Marlow <simonmar@microsoft.com>**20071206092349
 This fixes the 1959 test, but will do more recompilation than is
 strictly necessary (but only when -O is on).  Still, more
 recompilation is better than segfaults, link errors or other random
 breakage.
] 
[FIX part of #1959: declaration versions were not being incremented correctly
Simon Marlow <simonmar@microsoft.com>**20071206084556
 We were building a mapping from ModuleName to [Occ] from the usage
 list, using the usg_mod field as the key.  Unfortunately, due to a
 very poor naming decision, usg_mod is actually the module version, not
 the ModuleName.  usg_name is the ModuleName.  Since Version is also an
 instance of Uniquable, there was no type error: all that happened was
 lookups in the map never succeeded.  I shall rename the fields of
 Usage in a separate patch.
 
 This doesn't completely fix #1959, but it gets part of the way there.
 
 I have to take partial blame as the person who wrote this fragment of
 code in late 2006 (patch "Interface file optimisation and removal of
 nameParent").
] 
[move FP_FIND_ROOT after the "GHC is required" check
Simon Marlow <simonmar@microsoft.com>**20071205101814] 
[FIX #1110: hackery also needed when running gcc for CPP
Simon Marlow <simonmar@microsoft.com>**20071205150230] 
[Teach :print to follow references (STRefs and IORefs)
Pepe Iborra <mnislaih@gmail.com>**20071204105511
 
 Prelude Data.IORef> :p l
 l = (_t4::Maybe Integer) : (_t5::[Maybe Integer])
 Prelude Data.IORef> p <- newIORef l
 Prelude Data.IORef> :p p
 p = GHC.IOBase.IORef (GHC.STRef.STRef {((_t6::Maybe Integer) :
                                         (_t7::[Maybe Integer]))})
 Prelude Data.IORef> :sp p
 p = GHC.IOBase.IORef (GHC.STRef.STRef {(_ : _)})
 
 
 I used braces to denote the contents of a reference.
 Perhaps there is a more appropriate notation?
] 
[refactoring only
Pepe Iborra <mnislaih@gmail.com>**20071202125400] 
[Change --shared to -shared in Win32 DLL docs
simonpj@microsoft.com**20071204154023] 
[protect console handler against concurrent access (#1922)
Simon Marlow <simonmar@microsoft.com>**20071204153918] 
[Make eta reduction check more carefully for bottoms (fix Trac #1947)
simonpj@microsoft.com**20071204145803
 
 Eta reduction was wrongly transforming
        f = \x. f x
 to
        f = f
 
 Solution: don't trust f's arity information; instead look at its
 unfolding.  See Note [Eta reduction conditions]
 
 Almost all the new lines are comments!
 
 
] 
[Improve inlining for INLINE non-functions
simonpj@microsoft.com**20071204114955
        
 (No need to merge to 6.8, but no harm if a subsequent patch needs it.)
 
 The proximate cause for this patch is to improve the inlining for INLINE
 things that are not functions; this came up in the NDP project.  See
 Note [Lone variables] in CoreUnfold.
 
 This caused some refactoring that actually made things simpler.  In 
 particular, more of the inlining logic has moved from SimplUtils to 
 CoreUnfold, where it belongs.
 
 
] 
[fix race conditions in sandboxIO (#1583, #1922, #1946)
Simon Marlow <simonmar@microsoft.com>**20071204114444
 using the new block-inheriting forkIO (#1048)
] 
[:cd with no argument goes to the user's home directory
Simon Marlow <simonmar@microsoft.com>**20071204113945
 Seems better than getting a confusing 'cannot find directory' exception.
] 
[forkIO starts the new thread blocked if the parent is blocked (#1048)
Simon Marlow <simonmar@microsoft.com>**20071204110947] 
[Improve eta reduction, to reduce Simplifier iterations
simonpj@microsoft.com**20071203150039
 
 I finally got around to investigating why the Simplifier was sometimes
 iterating so often.  There's a nice example in Text.ParserCombinators.ReadPrec,
 which produced:
 
 NOTE: Simplifier still going after 3 iterations; bailing out.  Size = 339
 NOTE: Simplifier still going after 3 iterations; bailing out.  Size = 339
 NOTE: Simplifier still going after 3 iterations; bailing out.  Size = 339
 
 No progress is being made.  It turned out that an interaction between
 eta-expansion, casts, and eta reduction was responsible. The change is
 small and simple, in SimplUtils.mkLam: do not require the body to be
 a Lam when floating the cast outwards.  
 
 I also discovered a missing side condition in the same equation, so fixing
 that is good too.  Now there is no loop when compiling ReadPrec.
 
 Should do a full nofib run though.
 
] 
[Don't default to stripping binaries when installing
Ian Lynagh <igloo@earth.li>**20071202195817] 
[Improve pretty-printing for Insts
simonpj@microsoft.com**20071128173125] 
[Reorganise TcSimplify (again); FIX Trac #1919
simonpj@microsoft.com**20071128173146
 
 This was a bit tricky.  We had a "given" dict like (d7:Eq a); then it got
 supplied to reduceImplication, which did some zonking, and emerged with
 a "needed given" (d7:Eq Int). That got everything confused.
 
 I found a way to simplify matters significantly.  Now reduceContext
        - first deals with methods/literals/dictionaries
        - then deals with implications
 Separating things in this way not only made the bug go away, but
 eliminated the need for the recently-added "needed-givens" results returned
 by checkLoop.  Hurrah.
 
 It's still a swamp.  But it's a bit better.
 
] 
[FIX #1914: GHCi forgot all the modules that were loaded before an error
Simon Marlow <simonmar@microsoft.com>**20071130130734] 
[FIX #1744: ignore the byte-order mark at the beginning of a file
Simon Marlow <simonmar@microsoft.com>**20071130101100] 
[FIX Trac #1935: generate superclass constraints for derived classes
simonpj@microsoft.com**20071128150541
 
 This bug only reports a problem with phantom types, but actually
 there was quite a long-standing and significant omission in the
 constraint generation for derived classes.  See
 Note [Superclasses of derived instance] in TcDeriv.
 
 The test deriving-1935 tests both cases.
 
 
] 
[Print a bit more info in VarBinds (no need to merge)
simonpj@microsoft.com**20071128150354] 
[Check for duplicate bindings in CoreLint
simonpj@microsoft.com**20071128150214] 
[add comment
Simon Marlow <simonmar@microsoft.com>**20071128111417] 
[FIX #1916: don't try to convert float constants to int in CMM optimizer
Bertram Felgenhauer <int-e@gmx.de>**20071122095513] 
[give a more useful message when the static flags have not been initialised (#1938)
Simon Marlow <simonmar@microsoft.com>**20071127135435] 
[Rebuild utils with the stage1 compiler when making a bindist; fixes trac #1860
Ian Lynagh <igloo@earth.li>**20071127203959
 This is a bit unpleasant, as "make binary-dist" really shouldn't actually
 build anything, but it works.
] 
[Remove the --print-docdir flag
Ian Lynagh <igloo@earth.li>**20071127195605
 It wasn't doing the right thing for bindists. Let's rethink...
] 
[FIX #1925: the interpreter was not maintaining tag bits correctly
Simon Marlow <simonmar@microsoft.com>**20071127122614
 See comment for details
] 
[add missing instruction: ALLOC_AP_NOUPD
Simon Marlow <simonmar@microsoft.com>**20071127122604] 
[Check tag bits on the fun pointer of a PAP
Simon Marlow <simonmar@microsoft.com>**20071126160420] 
[canonicalise the path to HsColour
Simon Marlow <simonmar@microsoft.com>**20071126141614] 
[Consistently put www. on the front of haskell.org in URLs
Ian Lynagh <igloo@earth.li>**20071126215256] 
[Fix some more URLs
Ian Lynagh <igloo@earth.li>**20071126214147] 
[Tweak some URLs
Ian Lynagh <igloo@earth.li>**20071126194148] 
[Fix some links
Ian Lynagh <igloo@earth.li>**20071126184406] 
[Copy gmp stamps into bindists, so we don't try and rebuild gmp
Ian Lynagh <igloo@earth.li>**20071125211919] 
[On Windows, Delete the CriticalSection's we Initialize
Ian Lynagh <igloo@earth.li>**20071125125845] 
[On Windows, add a start menu link to the flag reference
Ian Lynagh <igloo@earth.li>**20071125124429] 
[Remove html/ from the paths we put in the start menu on Windows
Ian Lynagh <igloo@earth.li>**20071125124150] 
[MERGED: Make ":" in GHCi repeat the last command
Ian Lynagh <igloo@earth.li>**20071125122020
 Ian Lynagh <igloo@earth.li>**20071124231857
  It used to be a synonym for ":r" in 6.6.1, but this wasn't documented or
  known about by the developers. In 6.8.1 it was accidentally broken.
  This patch brings it back, but as "repeat the last command", similar to
  pressing enter in gdb. This is almost as good for people who want it to
  reload, and means that it can also be used to repeat commands like :step.
] 
[MERGED: Put library docs in a $pkg, rather than $pkgid, directory; fixes trac #1864
Ian Lynagh <igloo@earth.li>**20071124212305
 Ian Lynagh <igloo@earth.li>**20071124171220
] 
[Don't make a library documentation prologue
Ian Lynagh <igloo@earth.li>**20071124211943
 It's far too large now, and no-one complained when 6.8.1 didn't have one.
] 
[Don't put package version numbers in links in index.html
Ian Lynagh <igloo@earth.li>**20071124211629] 
[Define install-strip in Makefile
Ian Lynagh <igloo@earth.li>**20071124205037] 
[Define install-strip in distrib/Makefile
Ian Lynagh <igloo@earth.li>**20071124204803] 
[Install gmp from bindists; fixes trac #1848
Ian Lynagh <igloo@earth.li>**20071124185240] 
[(native gen) fix code generated for GDTOI on x86_32
Bertram Felgenhauer <int-e@gmx.de>**20071121063942
 See trac #1910.
] 
[Copy the INSTALL hack from mk/config.mk.in into distrib/Makefile-bin-vars.in
Ian Lynagh <igloo@earth.li>**20071124163028
 configure will set INSTALL to ./install-sh if it can't find it in the path,
 so we need to replace the . with the path to our root.
] 
[Make install-sh executable /before/ we try to find it
Ian Lynagh <igloo@earth.li>**20071124162450] 
[Document --info in the +RTS -? help
Ian Lynagh <igloo@earth.li>**20071123204352] 
[MERGED: If we have hscolour then make source code links in teh haddock docs
Ian Lynagh <igloo@earth.li>**20071123233113
 Fri Nov 23 13:15:59 PST 2007  Ian Lynagh <igloo@earth.li>
] 
[Tidy and trim the type environment in mkBootModDetails
simonpj@microsoft.com**20071123153519
 
 Should fix Trac #1833
 
 We were failing to trim the type envt in mkBootModDetails, so several
 functions all called (*), for example, were getting into the interface.
 Result chaos.  It only actually bites when we do the retyping-loop thing,
 which is why it's gone so long without a fix.
 
 
] 
[refactor: HscNothing and boot modules do not need desugaring
Simon Marlow <simonmar@microsoft.com>**20071123135237] 
[FIX #1910: fix code generated for GDTOI on x86_32
Bertram Felgenhauer <int-e@gmx.de>*-20071121102627] 
[Properly ppr InstEqs in wanteds of implication constraints
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20071122093002] 
[FIX #1910: fix code generated for GDTOI on x86_32
Bertram Felgenhauer <int-e@gmx.de>**20071121102627] 
[Add built-in Double operations to vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071122002517] 
[Teach vectorisation about Double
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071121054932] 
[Vectorise polyexprs with notes
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071121053102] 
[Make rebindable do-notation behave as advertised
simonpj@microsoft.com**20071121174914
 
 Adopt Trac #1537.  The patch ended up a bit bigger than I expected,
 so I suggest we do not merge this into the 6.8 branch.  But there
 is no funadamental reason why not.
 
 With this patch, rebindable do-notation really does type as if you
 had written the original (>>) and (>>=) operations in desguared form.
 
 I ended up refactoring some of the (rather complicated) error-context
 stuff in TcUnify, by pushing an InstOrigin into tcSubExp and its
 various calls. That means we could get rid of tcFunResTy, and the
 SubCtxt type.  This should improve error messages slightly
 in complicated situations, because we have an Origin to hand
 to instCall (in the (isSigmaTy actual_ty) case of tc_sub1).
 
 Thanks to Pepe for the first draft of the patch.
 
] 
[Add DEBUG-only flag -dsuppress-uniques to suppress printing of uniques
simonpj@microsoft.com**20071116152446
 
 This is intended only for debugging use: it makes it easier to
 compare two variants without the variations between uniques mattering.
 
 (Of course, you can't actually feed the output to the C compiler
 or assembler and expect anything sensible to happen!)
 
] 
[Add -dcore-lint when validating libraries
simonpj@microsoft.com**20071105164733] 
[Fix Trac #1913: check data const for derived types are in scope
simonpj@microsoft.com**20071121151428
 
 When deriving an instance, the data constructors should all be in scope.
 This patch checks the condition.
 
 
] 
[Fix Trac #1909: type of map in docs
simonpj@microsoft.com**20071120160152] 
[Move file locking into the RTS, fixing #629, #1109
Simon Marlow <simonmar@microsoft.com>**20071120140859
 File locking (of the Haskell 98 variety) was previously done using a
 static table with linear search, which had two problems: the array had
 a fixed size and was sometimes too small (#1109), and performance of
 lockFile/unlockFile was suboptimal due to the linear search.
 Also the algorithm failed to count readers as required by Haskell 98
 (#629).
 
 Now it's done using a hash table (provided by the RTS).  Furthermore I
 avoided the extra fstat() for every open file by passing the dev_t and
 ino_t into lockFile.  This and the improvements to the locking
 algorithm result in a healthy 20% or so performance increase for
 opening/closing files (see openFile008 test).
] 
[FIX Trac #1825: standalone deriving Typeable
simonpj@microsoft.com**20071120125732
 
 Standalone deriving of typeable now requires you to say
        instance Typeable1 Maybe
 which is exactly the shape of instance decl that is generated
 by a 'deriving( Typeable )' clause on the data type decl.
 
 This is a bit horrid, but it's the only consistent way, at least
 for now.  If you say something else, the error messages are helpful.
 
 MERGE to 6.8 branch
 
] 
[FIX #1715: egregious bug in ifaceDeclSubBndrs
simonpj@microsoft.com**20071120111723
 
 ifaceDeclSubBndrs didn't have an IfaceSyn case; but with type
 families an IfaceSyn can introduce subordinate binders.  Result:
 chaos.
 
 The fix is easy though.  Merge to 6.8 branch.
 
 
] 
[Always do 'setup makefile' before building each library
Simon Marlow <simonmar@microsoft.com>**20071120103329
 This forces preprocessing to happen, which is necessary if any of the
 .hsc files have been modified.  Without this change, a 'setup
 makefile' would be required by hand after a .hsc file changed.
 Fortunately 'setup makefile' isn't much extra work, and I've made it
 not overwrite GNUmakefile if it hasn't changed, which avoids
 recalculating the dependencies each time.
] 
[FIX #1847 (improve :browse! docs, fix unqual)
claus.reinke@talk21.com**20071108013147
 
 - add example to docs, explain how to interpret 
   output of `:browse! Data.Maybe`
 - print unqualified names according to current 
   context, not the context of the target module
 
] 
[Track changes to package ndp
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071120033716] 
[Temporary hack for passing PArrays from unvectorised to vectorised code
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071120024545] 
[Bind NDP stuff to [:.:] arrays
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071119020302] 
[Don't treat enumerations specially during vectorisation for the moment
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071119013729] 
[Fix bugs in vectorisation of case expressions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071119013714] 
[More built-in NDP combinators
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071119012205] 
[New vectorisation built-ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118051940] 
[Fix bug in conversion unvect/vect
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118051926] 
[Extend built-in vectorisation environments
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118045219] 
[Fix bug in generation of environments for vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118045203] 
[Add builtin var->var mapping to vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118042605] 
[Extend vectorisation built-in mappings with datacons
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118034351] 
[Change representation of parallel arrays of enumerations
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118033355] 
[Add vectorisation-related builtin
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071118031513] 
[Teach vectorisation about Bool
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071117042714] 
[Incomplete support for boxing during vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071117040739] 
[Make sure some TyCons always vectorise to themselves
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071117040537] 
[Simple conversion vectorised -> unvectorised
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071117023029] 
[Fix bug in case vectorisation
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071117015014] 
[Vectorisation of algebraic case expressions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071116074814] 
[More vectorisation-related built-ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071116061831] 
[Vectorisation utilities
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071116051037] 
[Add vectorisation built-ins
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071116050959] 
[Fix vectorisation of binders in case expressions
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20071116021833] 
[Two small typos in the flags summary (merge to 6.8 branch)
simonpj@microsoft.com**20071119134639] 
[Improve the situation for Trac #959: civilised warning instead of a trace msg
simonpj@microsoft.com**20071119122938
 
 This doesn't fix the root cause of the bug, but it makes the report
 more civilised, and points to further info.
 
] 
[FIX Trac #1806: test for correct arity for datacon in infix pattern patch
simonpj@microsoft.com**20071119114301
 
 Happily the fix is easy; pls merge
 
] 
[Accept x86_64-*-freebsd* as well as amd64-*-freebsd* in configure.ac
Ian Lynagh <igloo@earth.li>**20071117154502
 Patch from Brian P. O'Hanlon
] 
[Attempt at fixing #1873, #1360
Simon Marlow <simonmar@microsoft.com>**20071116152148
 
 I think I figured out a reasonable way to manage the GHCi context,
 comments welcome.
 
 Rule 1: external package modules in the context are persistent.  That
 is, when you say 'import Data.Maybe' it survives over :load, :add,
 :reload and :cd.
 
 Rule 2: :load and :add remove all home-package modules from the
 context and add the rightmost target, as a *-module if possible.  This
 is as before, and makes sense for :load because we're starting a new
 program; the old home-package modules don't make sense any more.  For
 :add, it usually does what you want, because the new target will
 become the context.
 
 Rule 3: any modules from the context that fail to load during a
 :reload are remembered, and re-added to the context at the next
 successful :reload.
 
 Claus' suggestion about adding the "remembered" modules to the prompt
 prefixed with a ! is implemented but commented out.  I couldn't
 decide whether it was useful or confusing.
 
 One difference that people might notice is that after a :reload where
 there were errors, GHCi would previously dump you in the most recent
 module that it loaded.  Now it dumps you in whatever subset of the
 current context still makes sense, and in the common case that will
 probably be {Prelude}.
] 
[Wibble to fix Trac #1901 (shorten messsage slightly)
simonpj@microsoft.com**20071116150341] 
[Improve links from flag reference to the relevant section; and improve doc of RankN flags
simonpj@microsoft.com**20071116145816] 
[FIX Trac #1901: check no existential context in H98 mode
simonpj@microsoft.com**20071116145609] 
[Improve documentation of data type declarations (Trac #1901)
simonpj@microsoft.com**20071116081841] 
[Change the command-line semantics for query commands
Simon Marlow <simonmar@microsoft.com>**20071116132046
 
 From the help text:
 
   Commands that query the package database (list, latest, describe,
   field) operate on the list of databases specified by the flags
   --user, --global, and --package-conf.  If none of these flags are
   given, the default is --global --user.
 
 This makes it possible to query just a single database (e.g. the
 global one without the user one), which needed tricks to accomplish
 before.
] 
[use "ghc-pkg latest --global" instead of "ghc-pkg list --simple-output"
Simon Marlow <simonmar@microsoft.com>**20071116122018
 The former now does the right thing: it uses the global database only,
 and picks the most recent package with the given name.
] 
[Disallow installing packages whose names  differ in case only.
Simon Marlow <simonmar@microsoft.com>**20071116121153
 --force overrides.  Requested by Duncan Coutts, with a view to
 treating package names as case-insensitive in the future.
] 
[FIX BUILD (with GHC 6.2.x): update .hi-boot file
Simon Marlow <simonmar@microsoft.com>**20071116101227] 
[FIX #1828: installing to a patch with spaces in 
Simon Marlow <simonmar@microsoft.com>**20071115155747
 We have to pass the path to gcc when calling windres, which itself
 might have spaces in.  Furthermore, we have to pass the path to gcc's
 tools to gcc.  This means getting the quoting right, and after much
 experimentation and reading of the windres sources I found something
 that works: passing --use-temp-files to windres makes it use its own
 implementation of quoting instead of popen(), and this does what we
 want.  Sigh.
] 
[on Windows, install to a directory with spaces (test for #1828)
Simon Marlow <simonmar@microsoft.com>**20071115155327] 
[FIX #1679: crash on returning from a foreign call
Simon Marlow <simonmar@microsoft.com>**20071115131635
 We forgot to save a pointer to the BCO over the foreign call.  Doing
 enough allocation and GC during the call could provoke a crash.
] 
[Avoid the use of unversioned package dependencies
Simon Marlow <simonmar@microsoft.com>**20071115103249
 Fortunately "ghc-pkg list $pkg --simple-output" is a good way to add
 the version number.
] 
[FIX #1596 (remove deprecated --define-name)
Simon Marlow <simonmar@microsoft.com>**20071114165323
 Also remove the old command-line syntax for ghc-pkg, which was not
 documented.  Do not merge.
] 
[FIX #1837: remove deprecated support for unversioned dependencies (do not merge)
Simon Marlow <simonmar@microsoft.com>**20071114161044
 
] 
[wibble
Pepe Iborra <mnislaih@gmail.com>**20071114233356] 
[Make pprNameLoc more robust in absence of loc information
Pepe Iborra <mnislaih@gmail.com>**20071114233343] 
[Try to manage the size of the text rendered for ':show bindings'
Pepe Iborra <mnislaih@gmail.com>**20071114231601] 
[Make the Term ppr depth aware
Pepe Iborra <mnislaih@gmail.com>**20071114183417] 
[Use paragraph fill sep where possible
Pepe Iborra <mnislaih@gmail.com>**20071114181233] 
[Make SpecConstr work again
simonpj@microsoft.com**20071115084242
 
 In a typo I'd written env instead of env', and as a result RULES are
 practically guaranteed not to work in a recursive group.  This pretty
 much kills SpecConstr in its tracks!
 
 Well done Kenny Lu for spotting this.  The fix is easy.
 
 Merge into 6.8 please.
 
 
 
] 
[Documentation only - fix typo in flags reference
Tim Chevalier <chevalier@alum.wellesley.edu>**20071115055748] 
[Avoid making Either String an instance of Monad in the Haddock parser
David Waern <david.waern@gmail.com>**20071114204050] 
[FIX 1463 (implement 'ghc-pkg find-module')
claus.reinke@talk21.com**20071109162652
 
 - the ticket asks for a module2package lookup in ghc-pkg
   (this would be useful to have in cabal, as well)
 
 - we can now ask which packages expose a module we need,
   eg, when preparing a cabal file or when getting errors
   after package reorganisations:
 
   $ ./ghc-pkg-inplace find-module Var
   c:/fptools/ghc/driver/package.conf.inplace:
       (ghc-6.9.20071106)
   
   $ ./ghc-pkg-inplace find-module Data.Sequence
   c:/fptools/ghc/driver/package.conf.inplace:
       containers-0.1
 
 - implemented as a minor variation on listPackages
 
 (as usual, it would be useful if one could combine 
 multiple queries into one)
 
] 
[remove --define-name from the --help usage message (#1596)
Simon Marlow <simonmar@microsoft.com>**20071114153417
 
] 
[FIX #1837: emit deprecated message for unversioned dependencies
Simon Marlow <simonmar@microsoft.com>**20071114153010] 
[Fix #782, #1483, #1649: Unicode GHCi input
Simon Marlow <simonmar@microsoft.com>**20071114151411
 GHCi input is now treated universally as UTF-8, except for the Windows
 console where we do the correct conversion from the current code
 page (see System.Win32.stringToUnicode).
 
 That leaves non-UTF-8 locales on Unix as unsupported, but (a) we only
 accept source files in UTF-8 anyway, and (b) UTF-8 is quite ubiquitous
 as the default locale.
 
] 
[Fix build
David Waern <david.waern@gmail.com>**20071114125842
 I had forgot to update HaddockLex.hi-boot-6, so the build with 6.2.2 
 failed. This fixes that.
] 
[FIX Trac 1662: actually check for existentials in proc patterns
simonpj@microsoft.com**20071114112930
 
 I'd fixed the bug for code that should be OK, but had forgotten to 
 make the test for code that should be rejected! 
 
 Test is arrowfail004
 
] 
[FIX Trac 1888; duplicate INLINE pragmas
simonpj@microsoft.com**20071114104701
 
 There are actually three things here
 - INLINE pragmas weren't being pretty-printed properly
 - They were being classified into too-narrow boxes by eqHsSig
 - They were being printed in to much detail by hsSigDoc
 
 All easy.  Test is rnfail048.
 
] 
[Run the -frule-check pass more often (when asked)
simonpj@microsoft.com**20071114104632] 
[GHCi debugger: added a new flag, -fno-print-binding-contents
Pepe Iborra <mnislaih@gmail.com>**20071113174539
 
 The contents of bindings show at breakpoints and by :show bindings
 is rendered using the same printer that :print uses.
 But sometimes the output it gives spans over too many lines and the
 user may want to be able to disable it.
] 
[Fix Trac 1865: GHCi debugger crashes with :print
Pepe Iborra <mnislaih@gmail.com>**20071113170113] 
[Replaced two uses of head b explicit pattern matching
Pepe Iborra <mnislaih@gmail.com>**20071013113136] 
[Print binding contents in :show bindings
Pepe Iborra <mnislaih@gmail.com>**20071006123952] 
[ Leftovers from the 1st GHCi debugger prototype
Pepe Iborra <mnislaih@gmail.com>**20071004204718] 
[Following an indirection doesn't count as a RTTI step
Pepe Iborra <mnislaih@gmail.com>**20070928091941] 
[FIX #1653 (partially): add -X flags to completion for :set
Simon Marlow <simonmar@microsoft.com>**20071113153257] 
[Merge from Haddock: Add <<url>> for images
David Waern <david.waern@gmail.com>**20071112220537
 A merge of this patch:
 
   Mon Aug  7 16:22:14 CEST 2006  Simon Marlow <simonmar@microsoft.com>
     * Add <<url>> for images
     Submitted by: Lennart Augustsson
 
 Please merge to the 6.8.2 branch.
] 
[Improve documentation of INLINE, esp its interactions with other transformations
simonpj@microsoft.com**20071112160240] 
[Comment re Trac #1220
simonpj@microsoft.com**20071112154109] 
[Merge from Haddock: Modify lexing of /../
David Waern <david.waern@gmail.com>**20071112023856
 
   Tue Aug 28 11:19:54 CEST 2007  Simon Marlow <simonmar@microsoft.com>
     * Modify lexing of /../ 
     This makes /../ more like '..', so that a single / on a line doesn't
     trigger a parse error.  This should reduce the causes of accidental
     parse errors in Haddock comments; apparently stray / characters are
     a common source of failures.
 
 Please merge this to the 6.8.2 branch.
] 
[Merge from Haddock: allow blank lines inside code blocks
David Waern <david.waern@gmail.com>**20071112013439
 
   Tue Jan  9 14:14:34 CET 2007  Simon Marlow <simonmar@microsoft.com>
     * allow blank lines inside a @...@ code block
 
 Please merge this to the 6.8.2 branch
] 
[Merge of a patch from the old Haddock branch:
David Waern <david.waern@gmail.com>**20071112013143
 
   Fri Jan  5 12:13:41 CET 2007  Simon Marlow <simonmar@microsoft.com>
     * Fix up a case of extra vertical space after a code block
 
 Please merge this to the 6.8.2 branch
] 
[Remove ex-extralibs from libraries/Makefile
Ian Lynagh <igloo@earth.li>**20071111213618] 
[Remove the X11 and HGL libraries from extralibs
Ian Lynagh <igloo@earth.li>**20071111213447
 Don Stewart, X11 maintainer, requested we remove X11, and HGL depends on it
 on Linux (and we don't try to build HGL on Windows).
] 
[arrows is no longer an extralib
Ian Lynagh <igloo@earth.li>**20071027123656] 
[Turn -fprint-bind-result off by default
Ian Lynagh <igloo@earth.li>**20071111001126] 
[TAG 2007-11-11
Ian Lynagh <igloo@earth.li>**20071111161540] 
Patch bundle hash:
59daf4383210373d00dd48cc1bb331e67ccabb08