Ticket #132: ghc.dpatch

New patches:

[Make the code compatible with the stricter labelled-field parsing rules
Ian Lynagh <igloo@earth.li>**20090725211817] {
hunk ./compiler/basicTypes/SrcLoc.lhs 293
-isGoodSrcSpan SrcSpanOneLine{} = True
-isGoodSrcSpan SrcSpanMultiLine{} = True
-isGoodSrcSpan SrcSpanPoint{} = True
+isGoodSrcSpan (SrcSpanOneLine{}) = True
+isGoodSrcSpan (SrcSpanMultiLine{}) = True
+isGoodSrcSpan (SrcSpanPoint{}) = True
hunk ./compiler/basicTypes/SrcLoc.lhs 324
-srcSpanStartLine SrcSpanOneLine{ srcSpanLine=l } = l
-srcSpanStartLine SrcSpanMultiLine{ srcSpanSLine=l } = l
-srcSpanStartLine SrcSpanPoint{ srcSpanLine=l } = l
+srcSpanStartLine (SrcSpanOneLine{ srcSpanLine=l }) = l
+srcSpanStartLine (SrcSpanMultiLine{ srcSpanSLine=l }) = l
+srcSpanStartLine (SrcSpanPoint{ srcSpanLine=l }) = l
hunk ./compiler/basicTypes/SrcLoc.lhs 329
-srcSpanEndLine SrcSpanOneLine{ srcSpanLine=l } = l
-srcSpanEndLine SrcSpanMultiLine{ srcSpanELine=l } = l
-srcSpanEndLine SrcSpanPoint{ srcSpanLine=l } = l
+srcSpanEndLine (SrcSpanOneLine{ srcSpanLine=l }) = l
+srcSpanEndLine (SrcSpanMultiLine{ srcSpanELine=l }) = l
+srcSpanEndLine (SrcSpanPoint{ srcSpanLine=l }) = l
hunk ./compiler/basicTypes/SrcLoc.lhs 334
-srcSpanStartCol SrcSpanOneLine{ srcSpanSCol=l } = l
-srcSpanStartCol SrcSpanMultiLine{ srcSpanSCol=l } = l
-srcSpanStartCol SrcSpanPoint{ srcSpanCol=l } = l
+srcSpanStartCol (SrcSpanOneLine{ srcSpanSCol=l }) = l
+srcSpanStartCol (SrcSpanMultiLine{ srcSpanSCol=l }) = l
+srcSpanStartCol (SrcSpanPoint{ srcSpanCol=l }) = l
hunk ./compiler/basicTypes/SrcLoc.lhs 339
-srcSpanEndCol SrcSpanOneLine{ srcSpanECol=c } = c
-srcSpanEndCol SrcSpanMultiLine{ srcSpanECol=c } = c
-srcSpanEndCol SrcSpanPoint{ srcSpanCol=c } = c
+srcSpanEndCol (SrcSpanOneLine{ srcSpanECol=c }) = c
+srcSpanEndCol (SrcSpanMultiLine{ srcSpanECol=c }) = c
+srcSpanEndCol (SrcSpanPoint{ srcSpanCol=c }) = c
hunk ./compiler/cmm/CmmBuildInfoTables.hs 199
-     return TopSRT { lbl = top_lbl, next_elt = 0, rev_elts = [], elt_map = emptyFM }
+     return $ TopSRT { lbl = top_lbl, next_elt = 0, rev_elts = [], elt_map = emptyFM }
hunk ./compiler/cmm/CmmLex.x 333
-getInput = P $ \s@PState{ loc=l, buffer=b } -> POk s (l,b)
+getInput = P $ \s@(PState{ loc=l, buffer=b }) -> POk s (l,b)
hunk ./compiler/cmm/CmmLex.x 336
-setInput (l,b) = P $ \s -> POk s{ loc=l, buffer=b } ()
+setInput (l,b) = P $ \s -> POk (s{ loc=l, buffer=b }) ()
hunk ./compiler/cmm/CmmProcPoint.hs 45
-      always_proc_point BrokenBlock {
-                              brokenBlockEntry = FunctionEntry _ _ _ } = True
-      always_proc_point BrokenBlock {
-                              brokenBlockEntry = ContinuationEntry _ _ _ } = True
+      always_proc_point (BrokenBlock {
+                              brokenBlockEntry = FunctionEntry _ _ _ }) = True
+      always_proc_point (BrokenBlock {
+                              brokenBlockEntry = ContinuationEntry _ _ _ }) = True
hunk ./compiler/cmm/OptimizationFuel.hs 38
-     return OptFuelState {pass_ref = pass_ref', fuel_ref = fuel_ref'}
+     return (OptFuelState {pass_ref = pass_ref', fuel_ref = fuel_ref'})
hunk ./compiler/codeGen/ClosureInfo.lhs 662
-blackHoleOnEntry _ ConInfo{} = False
+blackHoleOnEntry _ (ConInfo{}) = False
hunk ./compiler/codeGen/ClosureInfo.lhs 848
-closureUpdReqd ClosureInfo{ closureLFInfo = lf_info } = lfUpdatable lf_info
-closureUpdReqd ConInfo{} = False
+closureUpdReqd (ClosureInfo{ closureLFInfo = lf_info }) = lfUpdatable lf_info
+closureUpdReqd (ConInfo{}) = False
hunk ./compiler/codeGen/ClosureInfo.lhs 859
-closureIsThunk ClosureInfo{ closureLFInfo = lf_info } = isLFThunk lf_info
-closureIsThunk ConInfo{} = False
+closureIsThunk (ClosureInfo{ closureLFInfo = lf_info }) = isLFThunk lf_info
+closureIsThunk (ConInfo{}) = False
hunk ./compiler/codeGen/StgCmmClosure.hs 897
-blackHoleOnEntry _ ConInfo{} = False
+blackHoleOnEntry _ (ConInfo{}) = False
hunk ./compiler/codeGen/StgCmmClosure.hs 937
-closureUpdReqd ClosureInfo{ closureLFInfo = lf_info } = lfUpdatable lf_info
-closureUpdReqd ConInfo{} = False
+closureUpdReqd (ClosureInfo{ closureLFInfo = lf_info }) = lfUpdatable lf_info
+closureUpdReqd (ConInfo{}) = False
hunk ./compiler/codeGen/StgCmmClosure.hs 948
-closureIsThunk ClosureInfo{ closureLFInfo = lf_info } = isLFThunk lf_info
-closureIsThunk ConInfo{} = False
+closureIsThunk (ClosureInfo{ closureLFInfo = lf_info }) = isLFThunk lf_info
+closureIsThunk (ConInfo{}) = False
hunk ./compiler/deSugar/Coverage.lhs 658
-                 case m env{ inScope = inScope env `extendVarSetList` new_ids } st of
+                 case m (env{ inScope = inScope env `extendVarSetList` new_ids }) st of
hunk ./compiler/ghci/ByteCodeInstr.lhs 240
-bciStackUse STKCHECK{}            = 0
-bciStackUse PUSH_L{}             = 1
-bciStackUse PUSH_LL{}            = 2
-bciStackUse PUSH_LLL{}            = 3
-bciStackUse PUSH_G{}             = 1
-bciStackUse PUSH_PRIMOP{}         = 1
-bciStackUse PUSH_BCO{}           = 1
+bciStackUse (STKCHECK{})            = 0
+bciStackUse (PUSH_L{})           = 1
+bciStackUse (PUSH_LL{})          = 2
+bciStackUse (PUSH_LLL{})            = 3
+bciStackUse (PUSH_G{})                   = 1
+bciStackUse (PUSH_PRIMOP{})         = 1
+bciStackUse (PUSH_BCO{})         = 1
hunk ./compiler/ghci/ByteCodeInstr.lhs 250
-bciStackUse PUSH_APPLY_N{}       = 1
-bciStackUse PUSH_APPLY_V{}       = 1
-bciStackUse PUSH_APPLY_F{}       = 1
-bciStackUse PUSH_APPLY_D{}       = 1
-bciStackUse PUSH_APPLY_L{}       = 1
-bciStackUse PUSH_APPLY_P{}       = 1
-bciStackUse PUSH_APPLY_PP{}      = 1
-bciStackUse PUSH_APPLY_PPP{}     = 1
-bciStackUse PUSH_APPLY_PPPP{}    = 1
-bciStackUse PUSH_APPLY_PPPPP{}   = 1
-bciStackUse PUSH_APPLY_PPPPPP{}          = 1
-bciStackUse ALLOC_AP{}            = 1
-bciStackUse ALLOC_AP_NOUPD{}      = 1
-bciStackUse ALLOC_PAP{}           = 1
+bciStackUse (PUSH_APPLY_N{})     = 1
+bciStackUse (PUSH_APPLY_V{})     = 1
+bciStackUse (PUSH_APPLY_F{})     = 1
+bciStackUse (PUSH_APPLY_D{})     = 1
+bciStackUse (PUSH_APPLY_L{})     = 1
+bciStackUse (PUSH_APPLY_P{})     = 1
+bciStackUse (PUSH_APPLY_PP{})    = 1
+bciStackUse (PUSH_APPLY_PPP{})   = 1
+bciStackUse (PUSH_APPLY_PPPP{})          = 1
+bciStackUse (PUSH_APPLY_PPPPP{})         = 1
+bciStackUse (PUSH_APPLY_PPPPPP{})        = 1
+bciStackUse (ALLOC_AP{})            = 1
+bciStackUse (ALLOC_AP_NOUPD{})      = 1
+bciStackUse (ALLOC_PAP{})           = 1
hunk ./compiler/ghci/ByteCodeInstr.lhs 265
-bciStackUse LABEL{}              = 0
-bciStackUse TESTLT_I{}           = 0
-bciStackUse TESTEQ_I{}           = 0
-bciStackUse TESTLT_F{}           = 0
-bciStackUse TESTEQ_F{}           = 0
-bciStackUse TESTLT_D{}           = 0
-bciStackUse TESTEQ_D{}           = 0
-bciStackUse TESTLT_P{}           = 0
-bciStackUse TESTEQ_P{}           = 0
-bciStackUse CASEFAIL{}           = 0
-bciStackUse JMP{}                = 0
-bciStackUse ENTER{}              = 0
-bciStackUse RETURN{}             = 0
-bciStackUse RETURN_UBX{}         = 1
-bciStackUse CCALL{}              = 0
-bciStackUse SWIZZLE{}            = 0
-bciStackUse BRK_FUN{}            = 0
+bciStackUse (LABEL{})            = 0
+bciStackUse (TESTLT_I{})         = 0
+bciStackUse (TESTEQ_I{})         = 0
+bciStackUse (TESTLT_F{})         = 0
+bciStackUse (TESTEQ_F{})         = 0
+bciStackUse (TESTLT_D{})         = 0
+bciStackUse (TESTEQ_D{})         = 0
+bciStackUse (TESTLT_P{})         = 0
+bciStackUse (TESTEQ_P{})         = 0
+bciStackUse (CASEFAIL{})                 = 0
+bciStackUse (JMP{})              = 0
+bciStackUse (ENTER{})            = 0
+bciStackUse (RETURN{})           = 0
+bciStackUse (RETURN_UBX{})       = 1
+bciStackUse (CCALL{})            = 0
+bciStackUse (SWIZZLE{})          = 0
+bciStackUse (BRK_FUN{})          = 0
hunk ./compiler/ghci/ByteCodeInstr.lhs 285
-bciStackUse SLIDE{}              = 0
-bciStackUse MKAP{}               = 0
-bciStackUse MKPAP{}              = 0
-bciStackUse PACK{}               = 1 -- worst case is PACK 0 words
+bciStackUse (SLIDE{})            = 0
+bciStackUse (MKAP{})             = 0
+bciStackUse (MKPAP{})            = 0
+bciStackUse (PACK{})             = 1 -- worst case is PACK 0 words
hunk ./compiler/ghci/ByteCodeItbls.lhs 297
-           return  
+           return  $
hunk ./compiler/ghci/ByteCodeItbls.lhs 382
-           return 
+           return $
hunk ./compiler/ghci/Debugger.hs 160
-  cPprShowable prec t@Term{ty=ty, val=val} =
+  cPprShowable prec t@(Term{ty=ty, val=val}) =
hunk ./compiler/ghci/Debugger.hs 174
-           _ <- GHC.setSessionDynFlags dflags{log_action=noop_log}
+           _ <- GHC.setSessionDynFlags (dflags{log_action=noop_log})
hunk ./compiler/ghci/Debugger.hs 187
-  cPprShowable prec NewtypeWrap{ty=new_ty,wrapped_term=t} = 
-      cPprShowable prec t{ty=new_ty}
+  cPprShowable prec (NewtypeWrap{ty=new_ty,wrapped_term=t}) =
+      cPprShowable prec (t{ty=new_ty})
hunk ./compiler/ghci/Linker.lhs 658
-                       return lnk{ linkableUnlinked=new_uls }
+                       return $ lnk{ linkableUnlinked=new_uls }
hunk ./compiler/ghci/RtClosureInspect.hs 113
-isTerm Term{} = True
-isTerm   _    = False
-isSuspension Suspension{} = True
-isSuspension      _       = False
-isPrim Prim{} = True
-isPrim   _    = False
-isNewtypeWrap NewtypeWrap{} = True
-isNewtypeWrap _             = False
+isTerm (Term{}) = True
+isTerm _        = False
+isSuspension (Suspension{}) = True
+isSuspension _              = False
+isPrim (Prim{}) = True
+isPrim _        = False
+isNewtypeWrap (NewtypeWrap{}) = True
+isNewtypeWrap _               = False
hunk ./compiler/ghci/RtClosureInspect.hs 122
-isFun Suspension{ctype=Fun} = True
+isFun (Suspension{ctype=Fun}) = True
hunk ./compiler/ghci/RtClosureInspect.hs 125
-isFunLike s@Suspension{ty=ty} = isFun s || isFunTy ty
+isFunLike s@(Suspension{ty=ty}) = isFun s || isFunTy ty
hunk ./compiler/ghci/RtClosureInspect.hs 132
-isFullyEvaluatedTerm Term {subTerms=tt} = all isFullyEvaluatedTerm tt
-isFullyEvaluatedTerm Prim {}            = True
-isFullyEvaluatedTerm NewtypeWrap{wrapped_term=t} = isFullyEvaluatedTerm t
-isFullyEvaluatedTerm RefWrap{wrapped_term=t}     = isFullyEvaluatedTerm t
-isFullyEvaluatedTerm _                  = False
+isFullyEvaluatedTerm (Term {subTerms=tt}) = all isFullyEvaluatedTerm tt
+isFullyEvaluatedTerm (Prim {})            = True
+isFullyEvaluatedTerm (NewtypeWrap{wrapped_term=t}) = isFullyEvaluatedTerm t
+isFullyEvaluatedTerm (RefWrap{wrapped_term=t})     = isFullyEvaluatedTerm t
+isFullyEvaluatedTerm _                    = False
hunk ./compiler/ghci/RtClosureInspect.hs 300
-mapTermType f = foldTerm idTermFold {
+mapTermType f = foldTerm (idTermFold {
hunk ./compiler/ghci/RtClosureInspect.hs 305
-          fRefWrap    = \ty t -> RefWrap (f ty) t}
+          fRefWrap    = \ty t -> RefWrap (f ty) t})
hunk ./compiler/ghci/RtClosureInspect.hs 308
-mapTermTypeM f = foldTermM TermFoldM {
+mapTermTypeM f = foldTermM (TermFoldM {
hunk ./compiler/ghci/RtClosureInspect.hs 314
-          fRefWrapM    = \ty t -> f ty >>= \ty' -> return $ RefWrap ty' t}
+          fRefWrapM    = \ty t -> f ty >>= \ty' -> return $ RefWrap ty' t})
hunk ./compiler/ghci/RtClosureInspect.hs 317
-termTyVars = foldTerm TermFold {
+termTyVars = foldTerm (TermFold {
hunk ./compiler/ghci/RtClosureInspect.hs 323
-            fRefWrap    = \ty t -> tyVarsOfType ty `plusVarEnv` t}
+            fRefWrap    = \ty t -> tyVarsOfType ty `plusVarEnv` t})
hunk ./compiler/ghci/RtClosureInspect.hs 346
-ppr_termM y p Term{dc=Left dc_tag, subTerms=tt} = do
+ppr_termM y p (Term{dc=Left dc_tag, subTerms=tt}) = do
hunk ./compiler/ghci/RtClosureInspect.hs 350
-ppr_termM y p Term{dc=Right dc, subTerms=tt} 
+ppr_termM y p (Term{dc=Right dc, subTerms=tt})
hunk ./compiler/ghci/RtClosureInspect.hs 360
-ppr_termM y p t@NewtypeWrap{} = pprNewtypeWrap y p t
-ppr_termM y p RefWrap{wrapped_term=t}  = do
+ppr_termM y p t@(NewtypeWrap{}) = pprNewtypeWrap y p t
+ppr_termM y p (RefWrap{wrapped_term=t})  = do
hunk ./compiler/ghci/RtClosureInspect.hs 373
-ppr_termM1 Prim{value=words, ty=ty} = 
+ppr_termM1 (Prim{value=words, ty=ty}) =
hunk ./compiler/ghci/RtClosureInspect.hs 375
-ppr_termM1 Suspension{ty=ty, bound_to=Nothing} = 
+ppr_termM1 (Suspension{ty=ty, bound_to=Nothing}) =
hunk ./compiler/ghci/RtClosureInspect.hs 377
-ppr_termM1 Suspension{ty=ty, bound_to=Just n}
+ppr_termM1 (Suspension{ty=ty, bound_to=Just n})
hunk ./compiler/ghci/RtClosureInspect.hs 380
-ppr_termM1 Term{}        = panic "ppr_termM1 - Term"
-ppr_termM1 RefWrap{}     = panic "ppr_termM1 - RefWrap"
-ppr_termM1 NewtypeWrap{} = panic "ppr_termM1 - NewtypeWrap"
+ppr_termM1 (Term{})        = panic "ppr_termM1 - Term"
+ppr_termM1 (RefWrap{})     = panic "ppr_termM1 - RefWrap"
+ppr_termM1 (NewtypeWrap{}) = panic "ppr_termM1 - NewtypeWrap"
hunk ./compiler/ghci/RtClosureInspect.hs 384
-pprNewtypeWrap y p NewtypeWrap{ty=ty, wrapped_term=t}
+pprNewtypeWrap y p (NewtypeWrap{ty=ty, wrapped_term=t})
hunk ./compiler/ghci/RtClosureInspect.hs 429
-           (\ p Term{subTerms=[h,t]} -> doList p h t)
+           (\ p (Term{subTerms=[h,t]}) -> doList p h t)
hunk ./compiler/ghci/RtClosureInspect.hs 436
-     where ifTerm pred f prec t@Term{}
+     where ifTerm pred f prec t@(Term{})
hunk ./compiler/ghci/RtClosureInspect.hs 467
-                where getListTerms Term{subTerms=[h,t]} = h : getListTerms t
-                      getListTerms Term{subTerms=[]}    = []
-                      getListTerms t@Suspension{}       = [t]
+                where getListTerms (Term{subTerms=[h,t]}) = h : getListTerms t
+                      getListTerms (Term{subTerms=[]})    = []
+                      getListTerms t@(Suspension{})       = [t]
hunk ./compiler/ghci/RtClosureInspect.hs 758
-  expandNewtypes = foldTerm idTermFold { fTerm = worker } where
+  expandNewtypes = foldTerm (idTermFold { fTerm = worker }) where
hunk ./compiler/ghci/RtClosureInspect.hs 770
-  fixFunDictionaries = foldTerm idTermFold {fSuspension = worker} where
+  fixFunDictionaries = foldTerm (idTermFold {fSuspension = worker}) where
hunk ./compiler/ghci/RtClosureInspect.hs 1107
-zonkTerm = foldTermM TermFoldM{
+zonkTerm = foldTermM (TermFoldM{
hunk ./compiler/ghci/RtClosureInspect.hs 1117
-             }
+             })
hunk ./compiler/hsSyn/HsDecls.lhs 154
-    HsGroup { 
+    (HsGroup { 
hunk ./compiler/hsSyn/HsDecls.lhs 165
-  hs_docs   = docs1 }
-    HsGroup { 
+  hs_docs   = docs1 })
+    (HsGroup { 
hunk ./compiler/hsSyn/HsDecls.lhs 177
-  hs_docs   = docs2 }
+  hs_docs   = docs2 })
hunk ./compiler/hsSyn/HsDecls.lhs 572
-   isDataTy TyData{tcdND = DataType, tcdTyPats = Nothing} = True
-   isDataTy _                                             = False
+   isDataTy (TyData{tcdND = DataType, tcdTyPats = Nothing}) = True
+   isDataTy _                                               = False
hunk ./compiler/hsSyn/HsDecls.lhs 575
-   isNewTy TyData{tcdND = NewType, tcdTyPats = Nothing} = True
-   isNewTy _                                            = False
+   isNewTy (TyData{tcdND = NewType, tcdTyPats = Nothing}) = True
+   isNewTy _                                              = False
hunk ./compiler/hsSyn/HsDecls.lhs 651
-pp_condecls cs@(L _ ConDecl{ con_res = ResTyGADT _ } : _) -- In GADT syntax
+pp_condecls cs@(L _ (ConDecl{ con_res = ResTyGADT _ }) : _) -- In GADT syntax
hunk ./compiler/iface/BinIface.hs 133
-  bh <- return $! setUserData bh ud{ud_symtab = symtab}
+  bh <- return $! setUserData bh (ud{ud_symtab = symtab})
hunk ./compiler/iface/BinIface.hs 270
-putName BinSymbolTable{ 
+putName (BinSymbolTable{
hunk ./compiler/iface/BinIface.hs 272
-            bin_symtab_next = symtab_next }    bh name
+            bin_symtab_next = symtab_next })    bh name
hunk ./compiler/iface/BinIface.hs 293
-putFastString BinDictionary { bin_dict_next = j_r,
-                              bin_dict_map  = out_r}  bh f
+putFastString (BinDictionary { bin_dict_next = j_r,
+                               bin_dict_map  = out_r})  bh f
hunk ./compiler/iface/BinIface.hs 494
-    put_ bh usg@UsagePackageModule{} = do 
+    put_ bh usg@(UsagePackageModule{}) = do
hunk ./compiler/iface/BinIface.hs 498
-    put_ bh usg@UsageHomeModule{} = do 
+    put_ bh usg@(UsageHomeModule{}) = do
hunk ./compiler/iface/BinIface.hs 511
-            return UsagePackageModule { usg_mod = nm, usg_mod_hash = mod }
+            return $ UsagePackageModule { usg_mod = nm, usg_mod_hash = mod }
hunk ./compiler/iface/BinIface.hs 517
-            return UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,
+            return $ UsageHomeModule { usg_mod_name = nm, usg_mod_hash = mod,
hunk ./compiler/iface/IfaceEnv.lhs 170
-                setNameCache name_cache{ nsUniqs = us', nsNames = new_cache }
+                setNameCache (name_cache{ nsUniqs = us', nsNames = new_cache })
hunk ./compiler/iface/IfaceSyn.lhs 354
-ifaceDeclSubBndrs IfaceData {ifCons = IfAbstractTyCon}  = []
+ifaceDeclSubBndrs (IfaceData {ifCons = IfAbstractTyCon})  = []
hunk ./compiler/iface/IfaceSyn.lhs 681
-freeNamesIfDecl IfaceForeign{} = 
+freeNamesIfDecl (IfaceForeign{}) = 
hunk ./compiler/iface/IfaceSyn.lhs 683
-freeNamesIfDecl d@IfaceData{} =
+freeNamesIfDecl d@(IfaceData{}) =
hunk ./compiler/iface/IfaceSyn.lhs 688
-freeNamesIfDecl d@IfaceSyn{} =
+freeNamesIfDecl d@(IfaceSyn{}) =
hunk ./compiler/iface/IfaceSyn.lhs 692
-freeNamesIfDecl d@IfaceClass{} =
+freeNamesIfDecl d@(IfaceClass{}) =
hunk ./compiler/iface/LoadIface.lhs 672
-pprUsage usage@UsagePackageModule{}
+pprUsage usage@(UsagePackageModule{})
hunk ./compiler/iface/LoadIface.lhs 675
-pprUsage usage@UsageHomeModule{}
+pprUsage usage@(UsageHomeModule{})
hunk ./compiler/iface/MkIface.lhs 123
-        ModGuts{     mg_module    = this_mod,
+        (ModGuts{     mg_module    = this_mod,
hunk ./compiler/iface/MkIface.lhs 131
-                     mg_hpc_info  = hpc_info }
+                     mg_hpc_info  = hpc_info })
hunk ./compiler/iface/MkIface.lhs 145
-  tc_result@TcGblEnv{ tcg_mod = this_mod,
+ tc_result@(TcGblEnv{ tcg_mod = this_mod,
hunk ./compiler/iface/MkIface.lhs 152
-                    }
+                    })
hunk ./compiler/iface/MkIface.lhs 164
-          TcGblEnv{ tcg_inst_uses = dfun_uses_var,
+         (TcGblEnv{ tcg_inst_uses = dfun_uses_var,
hunk ./compiler/iface/MkIface.lhs 166
-                  }
+                  })
hunk ./compiler/iface/MkIface.lhs 173
-          TcGblEnv{ tcg_mod = mod,
+         (TcGblEnv{ tcg_mod = mod,
hunk ./compiler/iface/MkIface.lhs 176
-                  }
+                  })
hunk ./compiler/iface/MkIface.lhs 191
-      return Deps { dep_mods   = sortBy (stableModuleNameCmp `on` fst) dep_mods,
-                    dep_pkgs   = sortBy stablePackageIdCmp pkgs,
-                    dep_orphs  = sortBy stableModuleCmp (imp_orphs  imports),
-                    dep_finsts = sortBy stableModuleCmp (imp_finsts imports) }
+      return $ Deps { dep_mods   = sortBy (stableModuleNameCmp `on` fst) dep_mods,
+                      dep_pkgs   = sortBy stablePackageIdCmp pkgs,
+                      dep_orphs  = sortBy stableModuleCmp (imp_orphs  imports),
+                      dep_finsts = sortBy stableModuleCmp (imp_finsts imports) }
hunk ./compiler/iface/MkIface.lhs 207
-        ModDetails{  md_insts     = insts, 
+        (ModDetails{  md_insts            = insts, 
hunk ./compiler/iface/MkIface.lhs 213
-                     md_exports   = exports }
+                     md_exports   = exports })
hunk ./compiler/iface/MkIface.lhs 836
-      = Just UsagePackageModule{ usg_mod      = mod,
-                                 usg_mod_hash = mod_hash }
+      = Just (UsagePackageModule{ usg_mod      = mod,
+                                  usg_mod_hash = mod_hash })
hunk ./compiler/iface/MkIface.lhs 850
-      = Just UsageHomeModule { 
+      = Just (UsageHomeModule { 
hunk ./compiler/iface/MkIface.lhs 854
-                     usg_entities = fmToList ent_hashs }
+                     usg_entities = fmToList ent_hashs })
hunk ./compiler/iface/MkIface.lhs 1164
-checkModUsage _this_pkg UsagePackageModule{
+checkModUsage _this_pkg (UsagePackageModule{
hunk ./compiler/iface/MkIface.lhs 1166
-                                usg_mod_hash = old_mod_hash }
+                                usg_mod_hash = old_mod_hash })
hunk ./compiler/iface/MkIface.lhs 1174
-checkModUsage this_pkg UsageHomeModule{ 
+checkModUsage this_pkg (UsageHomeModule{
hunk ./compiler/iface/MkIface.lhs 1178
-                               usg_entities = old_decl_hash }
+                               usg_entities = old_decl_hash })
hunk ./compiler/iface/MkIface.lhs 1340
-    ifaceConDecls OpenTyCon {}                      = IfOpenDataTyCon
+    ifaceConDecls (OpenTyCon {})                    = IfOpenDataTyCon
hunk ./compiler/main/DynFlags.hs 577
- return dflags{
+ return $ dflags{
hunk ./compiler/main/Finder.lhs 430
-      return ModLocation{    ml_hs_file   = Nothing,
+      return $ ModLocation{    ml_hs_file   = Nothing,
hunk ./compiler/main/GHC.hs 1768
-  return hsc_env{ hsc_HPT = new_hpt }
+  return $ hsc_env{ hsc_HPT = new_hpt }
hunk ./compiler/main/GHC.hs 2084
-                 return old_summary{ ms_obj_date = obj_timestamp }
+                 return $ old_summary{ ms_obj_date = obj_timestamp }
hunk ./compiler/main/GHC.hs 2184
-               return (Just old_summary{ ms_obj_date = obj_timestamp })
+               return (Just $ old_summary{ ms_obj_date = obj_timestamp })
hunk ./compiler/main/HeaderInfo.hs 138
-     unsafeInterleaveIO $ lazyLexBuf handle state{buffer=newbuf} False
+     unsafeInterleaveIO $ lazyLexBuf handle (state{buffer=newbuf}) False
hunk ./compiler/main/HscTypes.lhs 1184
-substInteractiveContext ictxt@InteractiveContext{ic_tmp_ids=ids} subst =
+substInteractiveContext ictxt@(InteractiveContext{ic_tmp_ids=ids}) subst =
hunk ./compiler/main/InteractiveEval.hs 248
-        setSession hsc_env{  hsc_IC = old_IC{ ic_cwd = Just virt_dir } }
+        setSession $ hsc_env{  hsc_IC = old_IC{ ic_cwd = Just virt_dir } }
hunk ./compiler/main/InteractiveEval.hs 289
-                hsc_env' <- liftIO $ rttiEnvironment hsc_env{hsc_IC=final_ic}
+                hsc_env' <- liftIO $ rttiEnvironment $ hsc_env{hsc_IC=final_ic}
hunk ./compiler/main/InteractiveEval.hs 626
-   hsc_env1 <- rttiEnvironment hsc_env{ hsc_IC = ictxt1 }
+   hsc_env1 <- rttiEnvironment $ hsc_env{ hsc_IC = ictxt1 }
hunk ./compiler/main/InteractiveEval.hs 645
-rttiEnvironment hsc_env@HscEnv{hsc_IC=ic} = do
+rttiEnvironment hsc_env@(HscEnv{hsc_IC=ic}) = do
hunk ./compiler/main/InteractiveEval.hs 655
-     improveTypes hsc_env@HscEnv{hsc_IC=ic} name = do
+     improveTypes hsc_env@(HscEnv{hsc_IC=ic}) name = do
hunk ./compiler/main/InteractiveEval.hs 679
-                 return hsc_env{hsc_IC=ic'}
+                 return $ hsc_env{hsc_IC=ic'}
hunk ./compiler/main/InteractiveEval.hs 849
-getContext = withSession $ \HscEnv{ hsc_IC=ic } ->
+getContext = withSession $ \(HscEnv{ hsc_IC=ic }) ->
hunk ./compiler/main/InteractiveEval.hs 906
-greToRdrNames GRE{ gre_name = name, gre_prov = prov }
+greToRdrNames (GRE{ gre_name = name, gre_prov = prov })
hunk ./compiler/main/SysTools.lhs 227
-        ; return dflags1{
+        ; return $ dflags1{
hunk ./compiler/main/TidyPgm.lhs 116
-        TcGblEnv{ tcg_exports   = exports,
+       (TcGblEnv{ tcg_exports   = exports,
hunk ./compiler/main/TidyPgm.lhs 120
-                }
+                })
hunk ./compiler/main/TidyPgm.lhs 125
-        ModGuts{ mg_exports   = exports,
+       (ModGuts{ mg_exports   = exports,
hunk ./compiler/main/TidyPgm.lhs 129
-                }
+                })
hunk ./compiler/nativeGen/AsmCodeGen.lhs 192
-                               | stat@Color.RegAllocStatsStart{} <- stats]
+                               | stat@(Color.RegAllocStatsStart{}) <- stats]
hunk ./compiler/nativeGen/RegAlloc/Graph/Coalesce.hs 71
-       slurpCmm   rs  CmmData{}                         = rs
+       slurpCmm   rs (CmmData{})                        = rs
hunk ./compiler/nativeGen/RegAlloc/Graph/Coalesce.hs 90
-       slurpLI    rs SPILL{}   = rs
-       slurpLI    rs RELOAD{}  = rs
+       slurpLI    rs (SPILL{})         = rs
+       slurpLI    rs (RELOAD{})        = rs
hunk ./compiler/nativeGen/RegAlloc/Graph/Spill.hs 84
-regSpill_instr _ SPILL{}
+regSpill_instr _ (SPILL{})
hunk ./compiler/nativeGen/RegAlloc/Graph/Spill.hs 87
-regSpill_instr _ RELOAD{}
+regSpill_instr _ (RELOAD{})
hunk ./compiler/nativeGen/RegAlloc/Graph/SpillCost.hs 73
-       countCmm CmmData{}              = return ()
+       countCmm (CmmData{})            = return ()
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 66
- ppr (s@RegAllocStatsStart{})
+ ppr s@(RegAllocStatsStart{})
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 75
- ppr (s@RegAllocStatsSpill{})
+ ppr s@(RegAllocStatsSpill{})
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 100
- ppr (s@RegAllocStatsColored { raSRMs = (spills, reloads, moves) })
+ ppr s@(RegAllocStatsColored { raSRMs = (spills, reloads, moves) })
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 155
-       finals  = [ s   | s@RegAllocStatsColored{} <- stats]
+       finals  = [ s   | s@(RegAllocStatsColored{}) <- stats]
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 174
-                                       | s@RegAllocStatsStart{} <- stats ]
+                                       | s@(RegAllocStatsStart{}) <- stats ]
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 203
-                       [ raGraph s | s@RegAllocStatsStart{} <- stats ]
+                       [ raGraph s | s@(RegAllocStatsStart{}) <- stats ]
hunk ./compiler/nativeGen/RegAlloc/Graph/Stats.hs 221
-               $ [ raSpillCosts s | s@RegAllocStatsStart{} <- stats ]
+               $ [ raSpillCosts s | s@(RegAllocStatsStart{}) <- stats ]
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 70
-       (# state'@RA_State
+       (# state'@(RA_State
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 72
-               , ra_stack      = stack' }
+               , ra_stack      = stack' })
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 88
-spillR reg temp = RegM $ \ s@RA_State{ra_delta=delta, ra_stack=stack} ->
+spillR reg temp = RegM $ \ s@(RA_State{ra_delta=delta, ra_stack=stack}) ->
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 98
-loadR reg slot = RegM $ \ s@RA_State{ra_delta=delta} ->
+loadR reg slot = RegM $ \ s@(RA_State{ra_delta=delta}) ->
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 102
-getFreeRegsR = RegM $ \ s@RA_State{ra_freeregs = freeregs} ->
+getFreeRegsR = RegM $ \ s@(RA_State{ra_freeregs = freeregs}) ->
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 110
-getAssigR = RegM $ \ s@RA_State{ra_assig = assig} ->
+getAssigR = RegM $ \ s@(RA_State{ra_assig = assig}) ->
hunk ./compiler/nativeGen/RegAlloc/Linear/State.hs 118
-getBlockAssigR = RegM $ \ s@RA_State{ra_blockassig = assig} ->
+getBlockAssigR = RegM $ \ s@(RA_State{ra_blockassig = assig}) ->
hunk ./compiler/nativeGen/RegAlloc/Liveness.hs 223
- where slurpCmm   rs  CmmData{}                = rs
+ where slurpCmm   rs  (CmmData{})              = rs
hunk ./compiler/nativeGen/RegAlloc/Liveness.hs 302
- where slurpCmm cs CmmData{}   = cs
+ where slurpCmm cs (CmmData{}) = cs
hunk ./compiler/nativeGen/RegAlloc/Liveness.hs 464
-       patchCmm cmm@CmmData{}  = cmm
+       patchCmm cmm@(CmmData{})        = cmm
hunk ./compiler/nativeGen/RegAlloc/Liveness.hs 521
-               (Just live
+               (Just $ live
hunk ./compiler/nativeGen/RegAlloc/Liveness.hs 696
-       in Instr instr (Just live { liveBorn = rsBorn })
+       in Instr instr (Just $ live { liveBorn = rsBorn })
hunk ./compiler/parser/Lexer.x 1529
-setExts f = P $ \s -> POk s{ extsBitmap = f (extsBitmap s) } ()
+setExts f = P $ \s -> POk (s{ extsBitmap = f (extsBitmap s) }) ()
hunk ./compiler/parser/Lexer.x 1532
-setSrcLoc new_loc = P $ \s -> POk s{loc=new_loc} ()
+setSrcLoc new_loc = P $ \s -> POk (s{loc=new_loc}) ()
hunk ./compiler/parser/Lexer.x 1538
-setLastToken loc len line_len = P $ \s -> POk s { 
+setLastToken loc len line_len = P $ \s -> POk (s { 
hunk ./compiler/parser/Lexer.x 1542
-} ()
+}) ()
hunk ./compiler/parser/Lexer.x 1618
-getInput = P $ \s@PState{ loc=l, last_offs=o, buffer=b } -> POk s (AI l o b)
+getInput = P $ \s@(PState{ loc=l, last_offs=o, buffer=b }) -> POk s (AI l o b)
hunk ./compiler/parser/Lexer.x 1621
-setInput (AI l o b) = P $ \s -> POk s{ loc=l, last_offs=o, buffer=b } ()
+setInput (AI l o b) = P $ \s -> POk (s{ loc=l, last_offs=o, buffer=b }) ()
hunk ./compiler/parser/Lexer.x 1624
-pushLexState ls = P $ \s@PState{ lex_state=l } -> POk s{lex_state=ls:l} ()
+pushLexState ls = P $ \s@(PState{ lex_state=l }) -> POk (s{lex_state=ls:l}) ()
hunk ./compiler/parser/Lexer.x 1627
-popLexState = P $ \s@PState{ lex_state=ls:l } -> POk s{ lex_state=l } ls
+popLexState = P $ \s@(PState{ lex_state=ls:l }) -> POk (s{ lex_state=l }) ls
hunk ./compiler/parser/Lexer.x 1630
-getLexState = P $ \s@PState{ lex_state=ls:_ } -> POk s ls
+getLexState = P $ \s@(PState{ lex_state=ls:_ }) -> POk s ls
hunk ./compiler/parser/Lexer.x 1791
- = P $ \s@PState{messages=(ws,es), dflags=d} ->
+ = P $ \s@(PState{messages=(ws,es), dflags=d}) ->
hunk ./compiler/parser/Lexer.x 1794
-       in POk s{messages=(ws', es)} ()
+       in POk (s{messages=(ws', es)}) ()
hunk ./compiler/parser/Lexer.x 1797
-getMessages PState{messages=ms} = ms
+getMessages (PState{messages=ms}) = ms
hunk ./compiler/parser/Lexer.x 1800
-getContext = P $ \s@PState{context=ctx} -> POk s ctx
+getContext = P $ \s@(PState{context=ctx}) -> POk s ctx
hunk ./compiler/parser/Lexer.x 1803
-setContext ctx = P $ \s -> POk s{context=ctx} ()
+setContext ctx = P $ \s -> POk (s{context=ctx}) ()
hunk ./compiler/parser/Lexer.x 1809
-       (_:tl) -> POk s{ context = tl } ()
+       (_:tl) -> POk (s{ context = tl }) ()
hunk ./compiler/parser/Lexer.x 1816
-pushCurrentContext = P $ \ s@PState{ last_offs=offs, last_line_len=len, context=ctx } -> 
-    POk s{context = Layout (offs-len) : ctx} ()
+pushCurrentContext = P $ \ s@(PState{ last_offs=offs, last_line_len=len, context=ctx }) ->
+    POk (s{context = Layout (offs-len) : ctx}) ()
hunk ./compiler/parser/Lexer.x 1821
-getOffside = P $ \s@PState{last_offs=offs, context=stk} ->
+getOffside = P $ \s@(PState{last_offs=offs, context=stk}) ->
hunk ./compiler/parser/Lexer.x 1846
-srcParseFail = P $ \PState{ buffer = buf, last_len = len,      
-                           last_loc = last_loc } ->
+srcParseFail = P $ \(PState{ buffer = buf, last_len = len,     
+                           last_loc = last_loc }) ->
hunk ./compiler/prelude/ForeignCall.lhs 82
-playSafe PlaySafe{} = True
-playSafe PlayRisky  = False
+playSafe (PlaySafe{}) = True
+playSafe PlayRisky    = False
hunk ./compiler/rename/RnSource.lhs 472
-    rnATInst tydecl@TyData     {} = rnTyClDecl tydecl
-    rnATInst tydecl@TySynonym  {} = rnTyClDecl tydecl
+    rnATInst tydecl@(TyData     {}) = rnTyClDecl tydecl
+    rnATInst tydecl@(TySynonym  {}) = rnTyClDecl tydecl
hunk ./compiler/rename/RnSource.lhs 644
-rnTyClDecl (tydecl@TyFamily {}) =
+rnTyClDecl tydecl@(TyFamily {}) =
hunk ./compiler/rename/RnSource.lhs 648
-rnTyClDecl tydecl@TyData {tcdND = new_or_data, tcdCtxt = context, 
+rnTyClDecl tydecl@(TyData {tcdND = new_or_data, tcdCtxt = context, 
hunk ./compiler/rename/RnSource.lhs 651
-                          tcdKindSig = sig, tcdDerivs = derivs}
+                          tcdKindSig = sig, tcdDerivs = derivs})
hunk ./compiler/rename/RnSource.lhs 924
-rnFamily (tydecl@TyFamily {tcdFlavour = flavour, 
+rnFamily tydecl@(TyFamily {tcdFlavour = flavour, 
hunk ./compiler/rename/RnSource.lhs 945
-    rn_at (tydecl@TyFamily  {}) = rnFamily tydecl lookupIdxVars
-    rn_at (tydecl@TySynonym {}) = 
+    rn_at tydecl@(TyFamily  {}) = rnFamily tydecl lookupIdxVars
+    rn_at tydecl@(TySynonym {}) = 
hunk ./compiler/simplCore/SimplMonad.lhs 207
-doFreeTick tick sc@SimplCount { details = dts } 
+doFreeTick tick sc@(SimplCount { details = dts })
hunk ./compiler/simplCore/SimplMonad.lhs 211
-doTick tick sc@SimplCount { ticks = tks, details = dts, n_log = nl, log1 = l1 }
+doTick tick sc@(SimplCount { ticks = tks, details = dts, n_log = nl, log1 = l1 })
hunk ./compiler/typecheck/Inst.lhs 841
-lookupSimpleInst (LitInst { tci_lit = lit@OverLit { ol_val = lit_val
-                                                 , ol_rebindable = rebindable }
+lookupSimpleInst (LitInst { tci_lit = lit@(OverLit { ol_val = lit_val
+                                                 , ol_rebindable = rebindable })
hunk ./compiler/typecheck/TcRnDriver.lhs 671
-        eqAlgRhs OpenTyCon{} OpenTyCon{} = True
-        eqAlgRhs tc1@DataTyCon{} tc2@DataTyCon{} =
+        eqAlgRhs (OpenTyCon{}) (OpenTyCon{}) = True
+        eqAlgRhs tc1@(DataTyCon{}) tc2@(DataTyCon{}) =
hunk ./compiler/typecheck/TcRnDriver.lhs 674
-        eqAlgRhs tc1@NewTyCon{} tc2@NewTyCon{} =
+        eqAlgRhs tc1@(NewTyCon{}) tc2@(NewTyCon{}) =
hunk ./compiler/typecheck/TcTyClsDecls.lhs 268
-tcFamInstDecl1 (decl@TySynonym {tcdLName = L loc tc_name})
+tcFamInstDecl1 decl@(TySynonym {tcdLName = L loc tc_name})
hunk ./compiler/typecheck/TcTyClsDecls.lhs 299
-tcFamInstDecl1 (decl@TyData {tcdND = new_or_data, tcdLName = L loc tc_name,
+tcFamInstDecl1 decl@(TyData {tcdND = new_or_data, tcdLName = L loc tc_name,
hunk ./compiler/typecheck/TcTyClsDecls.lhs 468
-    allDecls (decl@ClassDecl {tcdATs = ats}) = decl : [ at 
+    allDecls decl@(ClassDecl {tcdATs = ats}) = decl : [ at 
hunk ./compiler/typecheck/TcTyFuns.lhs 991
-applySubstRules eq todoEqs (eqConfig@EqConfig {eqs = resEqs})
+applySubstRules eq todoEqs eqConfig@(EqConfig {eqs = resEqs})
hunk ./compiler/types/TyCon.lhs 325
-visibleDataCons OpenTyCon {}                 = []
+visibleDataCons (OpenTyCon {})               = []
hunk ./compiler/utils/Binary.hs 616
-  return UserData { ud_dict     = dict,
-                    ud_symtab   = undef "symtab",
-                    ud_put_name = undef "put_name",
-                    ud_put_fs   = undef "put_fs"
-                   }
+  return $ UserData { ud_dict     = dict,
+                      ud_symtab   = undef "symtab",
+                      ud_put_name = undef "put_name",
+                      ud_put_fs   = undef "put_fs"
+                     }
hunk ./compiler/utils/Binary.hs 626
-  return UserData { ud_dict     = undef "dict",
-                    ud_symtab   = undef "symtab",
-                    ud_put_name = put_name,
-                    ud_put_fs   = put_fs
-                   }
+  return $ UserData { ud_dict     = undef "dict",
+                      ud_symtab   = undef "symtab",
+                      ud_put_name = put_name,
+                      ud_put_fs   = put_fs
+                     }
hunk ./compiler/utils/GraphOps.hs 111
-       Just Node{}
+       Just (Node{})
hunk ./compiler/utils/GraphOps.hs 150
-                       (newNode u c)  { nodeConflicts = unitUniqSet u' }
+                       ((newNode u c) { nodeConflicts = unitUniqSet u' })
hunk ./compiler/utils/GraphOps.hs 198
-               (newNode u (getClass u))        { nodeConflicts = set' }
+               ((newNode u (getClass u))       { nodeConflicts = set' })
hunk ./compiler/utils/GraphOps.hs 213
-               (newNode u (getClass u))        { nodeExclusions = unitUniqSet color }
+               ((newNode u (getClass u))       { nodeExclusions = unitUniqSet color })
hunk ./compiler/utils/GraphOps.hs 236
-                       (newNode u c)  { nodeCoalesce = unitUniqSet u' }
+                       ((newNode u c)  { nodeCoalesce = unitUniqSet u' })
hunk ./compiler/utils/GraphOps.hs 268
-               (newNode u c)  { nodePreference = [color] }
+               ((newNode u c)  { nodePreference = [color] })
hunk ./ghc/GhciMonad.hs 265
-    _ <- GHC.setSessionDynFlags dflags {log_action = logAction encoder}
+    _ <- GHC.setSessionDynFlags (dflags {log_action = logAction encoder})
hunk ./ghc/InteractiveUI.hs 344
-   startGHCi (runGHCi srcs maybe_exprs)
+   startGHCi (runGHCi srcs maybe_exprs) $
hunk ./ghc/InteractiveUI.hs 568
-    c:cs -> do setGHCiState st{ cmdqueue = cs }
+    c:cs -> do setGHCiState (st{ cmdqueue = cs })
hunk ./ghc/InteractiveUI.hs 606
-      lift $ setGHCiState st{ prompt = "%s| " }
+      lift $ setGHCiState (st{ prompt = "%s| " })
hunk ./ghc/InteractiveUI.hs 608
-      lift $ getGHCiState >>= \st->setGHCiState st{ prompt = p }
+      lift $ getGHCiState >>= \st->setGHCiState (st{ prompt = p })
hunk ./ghc/InteractiveUI.hs 634
-  setGHCiState st{ cmdqueue = cmds ++ cmdqueue st }
+  setGHCiState (st{ cmdqueue = cmds ++ cmdqueue st })
hunk ./ghc/InteractiveUI.hs 751
-  setGHCiState st{ last_command = mc }
+  setGHCiState (st{ last_command = mc })
hunk ./ghc/InteractiveUI.hs 1121
-          setGHCiState st{ remembered_ctx = [] }
+          setGHCiState (st{ remembered_ctx = [] })
hunk ./ghc/InteractiveUI.hs 1277
-       setGHCiState st{ remembered_ctx = remembered_ctx st ++ [(cmd,as,bs)] }
+       setGHCiState (st{ remembered_ctx = remembered_ctx st ++ [(cmd,as,bs)] })
hunk ./ghc/InteractiveUI.hs 1397
-  setGHCiState st{ args = args }
+  setGHCiState $ st{ args = args }
hunk ./ghc/InteractiveUI.hs 1401
-  setGHCiState st{ progname = prog }
+  setGHCiState $ st{ progname = prog }
hunk ./ghc/InteractiveUI.hs 1405
-  setGHCiState st{ editor = cmd }
+  setGHCiState $ st{ editor = cmd }
hunk ./ghc/InteractiveUI.hs 1419
-       setGHCiState st{ breaks = new_breaks }
+       setGHCiState $ st{ breaks = new_breaks }
hunk ./ghc/InteractiveUI.hs 1422
-  setGHCiState st{ stop = cmd }
+  setGHCiState $ st{ stop = cmd }
hunk ./ghc/InteractiveUI.hs 2213
-        setGHCiState st{tickarrays = extendModuleEnv arrmap modl arr}
+        setGHCiState $ st{tickarrays = extendModuleEnv arrmap modl arr}
hunk ./ghc/InteractiveUI.hs 2219
-   setGHCiState st{tickarrays = emptyModuleEnv}
+   setGHCiState $ st{tickarrays = emptyModuleEnv}
}

Context:

[Add an extension to disable n+k patterns
Ian Lynagh <igloo@earth.li>**20090725134703] 
[Fix a warning on Windows
Ian Lynagh <igloo@earth.li>**20090724221244] 
[Remove GHC's haskell98 dependency
Ian Lynagh <igloo@earth.li>**20090724210825] 
[add number of bytes to +RTS -DS leak reports
Simon Marlow <marlowsd@gmail.com>**20090724150010
 Ignore-this: 3a66585c8fd2b58ce96abab1e154fb6e
] 
[free the gc_thread structures during shutdown
Simon Marlow <marlowsd@gmail.com>**20090724145956
 Ignore-this: 25efeb189cbfb549af4550d266604f0e
] 
[Add atomic_inc()/atomic_dec(), and use them to replace gc_running_mutex
Simon Marlow <marlowsd@gmail.com>**20090724142620
 Ignore-this: d775eeaf85fd0f9064d87a0909134bc0
 This also fixes a memory leak on Windows with -threaded, because we
 were calling initMutex(&gc_running_mutex) for each GC, which allocates
 memory.
] 
[Rewrite the foreign import string parser using ReadP
Simon Marlow <marlowsd@gmail.com>**20090723152138
 Ignore-this: 1c7db770a29d48710b05e2a3d216b2a8
 And kill the duplicate one in HsSyn.Convert
] 
[point to the wiki
Simon Marlow <marlowsd@gmail.com>**20090723132345
 Ignore-this: c11300bac62ce2f56d7fc271aa26dbcd
] 
[Remove note about avoiding use of #def in libraries
Simon Marlow <marlowsd@gmail.com>**20090723111026
 Ignore-this: 8a027ed37b2d10094f7a31548aee2535
 It should be safe to use now that we aren't relying on C prototypes
 for foreign functions in via-C code.
] 
[refactorings
Simon Marlow <marlowsd@gmail.com>**20090723091230
 Ignore-this: 836feb0e819127603dd56623af6e48dc
] 
[Fix Trac #3391: make generic to/from bindings only for newly-declared types
simonpj@microsoft.com**20090723155803
 Ignore-this: bb56c2ec054397d421dce13d5eb6c73f
 
 Before this patch we were bogusly making to/from bindings for all data types
 in the TcGblEnv.  But that is wrong when we have multiple "chunks" of 
 bindings in Template Haskell.  We should start from the declarations 
 themselves.  Easy.
 
] 
[Print explicit braces and semicolons in do-notation
simonpj@microsoft.com**20090723152411
 Ignore-this: a97ddf19774d27d15a01d63787708b20
 
 By printing explicit braces we make it more likely that pretty-printed
 code will be acceptable if fed back into GHC.
 
 See http://www.haskell.org/pipermail/glasgow-haskell-users/2009-July/017554.html
 
] 
[Documentation for stand-alone deriving (Trac #3012)
simonpj@microsoft.com**20090723132558
 Ignore-this: 54445c5984594eb7f82151b2ac118695
] 
[Windows only: set the encoding on stdin to utf8
Simon Marlow <marlowsd@gmail.com>**20090723121913
 Ignore-this: d65115d9711b5fb68e77786565ef6de
 Otherwise it defaults to latin1.
] 
[Fix Trac #3012: allow more free-wheeling in standalone deriving
simonpj@microsoft.com**20090723130145
 Ignore-this: 357580b9388ccbe1da3c1da3ba90e456
 
 In standalone deriving, we now do *not* check side conditions.
 We simply generate the code and typecheck it.  If there's a type
 error, it's the programmer's problem. 
 
 This means that you can do 'deriving instance Show (T a)', where
 T is a GADT, for example, provided of course that the boilerplate
 code does in fact typecheck.
 
 I put some work into getting a decent error message.  In particular
 if there's a type error in a method, GHC will show the entire code
 for that method (since, after all, the user did not write it).
 Most of the changes are to achieve that goal.
 
 Still to come: changes in the documentation.
 
] 
[Use the ErrMsg record type
simonpj@microsoft.com**20090723130108
 Ignore-this: 7fb6dd78d3185da0c33901b8aac8d108
] 
[Stop generating redundant parens in 'deriving' code
simonpj@microsoft.com**20090723125903
 Ignore-this: 6fc82df9648a82bcf7bf6fdfa9b4dad3
 
 This makes the code printed by -ddump-deriv look prettier
 
] 
[Wibble to printing tuple sections
simonpj@microsoft.com**20090723125756
 Ignore-this: af2a1b9784f6447fea0e11d454cf082f
] 
[Fix Trac #3193: improve line number reporting for equality constraints
simonpj@microsoft.com**20090723065504
 Ignore-this: b45a68071bcaca48cad7855dccb9c9eb
 
 When reporting an error from a failed equality constraint, we were
 setting the *context* but not the *line number* in TcTyFuns.eqInstMisMatch
 As a result, the line number didn't match the context at all.  It's
 trivial to fix.
 
 I'm 99% certain this fixes #3193, but it's too complicated to
 reproduce, so I have not actually tested it.
 
] 
[Add fmapM_maybe :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b)
simonpj@microsoft.com**20090723064932
 Ignore-this: db5f6319b52a5e6b5f85d76985f2a7c9
 
 This function isn't used at the moment, but Max added it, and it
 looks useful.
 
] 
[Add tuple sections as a new feature
simonpj@microsoft.com**20090723063859
 Ignore-this: d42a26fc1efff112b852b5c1135c1746
 
 This patch adds tuple sections, so that
 
        (x,,z)  means   \y -> (x,y,z)
 
 Thanks for Max Bolinbroke for doing the hard work.
 
 In the end, instead of using two constructors in HsSyn, I used
 just one (still called ExplicitTuple) whose arguments can be
        Present (LHsExpr id)
 or     Missing PostTcType
 
 While I was at it, I did a bit of refactoring too.
 
] 
[NetBSD defines _REENTRANT in its header files, so compiling ghc gives
Simon Marlow <marlowsd@gmail.com>**20090723075030
 Ignore-this: 4722c4ff0541c6080de8f433e498684
 redefinition warnings for all files that are including includes/Rts.h.
 
 Contributed by: Krister Walfridsson <krister.walfridsson@gmail.com>
] 
[includes/TSO.h: kill trailing whitespace
Samuel Bronson <naesten@gmail.com>**20090722170354
 Ignore-this: 36d4afd1a21188d604ed6b432942dcdc
] 
[Say what StgTSOBlockInfo is for, where to read about it.
Samuel Bronson <naesten@gmail.com>**20090722163011
 Ignore-this: 6c09e11f23594251cdc2db1bc642edc9
] 
[Make the Integer library used directly configurable in GHC and base
Ian Lynagh <igloo@earth.li>**20090722151048
 Rather than indirecting through an integer package
] 
[thenIO, bindIO, returnIO moved to GHC.Base
Simon Marlow <marlowsd@gmail.com>**20090722102219
 Ignore-this: 5d6c5988e0abab2c5169540aa8ddedb9
] 
[remove unused $(HscIfaceFileVersion)
Simon Marlow <marlowsd@gmail.com>**20090720145053
 Ignore-this: d725cbbde3c68673e2342b370460d87f
] 
[Choose external names more predictably
Simon Marlow <marlowsd@gmail.com>**20090720144751
 Ignore-this: 17513bc93af646108f21bbed1c8f4a3a
 
 Now, for a compiler-generated binding "x", if "x" is referred to by
 the exported "f", then it will be named "f_x" rather than something
 like "x23".  This means that hopefully
 
   - compilation will more often product the same results given the
     same input (the choice of names is not dependent on the
     non-deterministic order of bindings within the compiler).
 
   - less recompilation will be necessary after making changes
 
   - navigating Core might be a bit easier.
 
 unfortunately, compilation with -O still does not consistently produce
 the same ABI.  The simplifier sometimes does different things,
 apparently.
 
 Names will be longer, but I can't see a way around that.
] 
[Use stable ordering in the dependencies
Simon Marlow <marlowsd@gmail.com>**20090717123449
 Ignore-this: e20bac233cf6f834e69c027ff60b5b50
 Fixes another cause of wobbly interface files and unnecessary recompilation.
] 
[fall back on libffi for 'foreign import "wrapper"' if necessary
Simon Marlow <marlowsd@gmail.com>**20090716134549
 Ignore-this: e1073e1ad77e720326865a6d3c4f3790
] 
[Take account of GADTs when reporting patterm-match overlap
simonpj@microsoft.com**20090722050933
 Ignore-this: 7dcbdcb91021e83e6e6208a2e68c50c9
 
 When matching against a GADT, some of the constructors may be impossible.
 For example
        data T a where
           T1 :: T Int
           T2 :: T Bool
           T3 :: T a
 
         f :: T Int -> Int
         f T1 = 3
         f T3 = 4
 
 Here, does not have any missing cases, despite omittting T2, because
 T2 :: T Bool.
 
 This patch teaches the overlap checker about GADTs, which happily
 turned out to be rather easy even though the overlap checker needs
 a serious rewrite.
 
] 
[Fix Trac #3382: desugaring of NPats
simonpj@microsoft.com**20090720061226
 Ignore-this: 4dccdaf2b7d6428141dcf174cb455a20
 
 Max spotted that the short-cut rules for desugaring NPats (where
 we compare against a literal) were wrong now that we have overloaded
 strings.
 
] 
[Fix cleaning with the new integer changes
Ian Lynagh <igloo@earth.li>**20090722142545] 
[Add integer-simple as a build option
Ian Lynagh <igloo@earth.li>**20090722013137] 
[Tweak whitespace
Ian Lynagh <igloo@earth.li>**20090719221303] 
[Add a -fwarn-dodgy-exports flag; fixes #1911
Ian Lynagh <igloo@earth.li>**20090719200124
 This is used to control warnings that were previously unconditional.
] 
[Build terminfo if we /aren't/ on Windows, not if we /are/
Ian Lynagh <igloo@earth.li>**20090719111709] 
[Change how PACKAGES is constructed, so that everything gets cleaned properly
Ian Lynagh <igloo@earth.li>**20090718210058
 If Windows wasn't defined properly then the Win32 package wasn't being
 cleaned, as it wasn't added to PACKAGES. Now we always add everything to
 PACKAGES when CLEANING=YES.
] 
[temporarily turn off unused import warnings for the time library
Ian Lynagh <igloo@earth.li>**20090718183445] 
[Follow the split directory rename in the GHC build system rules
Ian Lynagh <igloo@earth.li>**20090718155618] 
[Fix Trac #3346: tcSimplify for LHS of RULES with type equalities
simonpj@microsoft.com**20090717155722
 Ignore-this: dfdd0f9a62d78d63276a4d558831099c
] 
[Add osuf to the name we use for the split dir
Ian Lynagh <igloo@earth.li>**20090718145522
 This avoids a collision between the directories we use when compiling
 multiple ways, which in turn leads to a race condition in parallel
 builds.
] 
[Temporarily turn off unused-do-bind warnings for the time package
Ian Lynagh <igloo@earth.li>**20090718134536] 
[Make ghc-cabal handle "Custom" Setup.hs files that have a configure script
Ian Lynagh <igloo@earth.li>**20090718131555] 
[Add the time library, and support for libraries in tarballs
Ian Lynagh <igloo@earth.li>**20090718121649] 
[Always serialise Int as 64bit values; fixes trac #3041
Ian Lynagh <igloo@earth.li>**20090717224203
 This means that, provided the values are small enough, files
 serialized are portable between architectures. In particular,
 .haddock files are portable.
] 
[Remove some code that has always been commented out
Ian Lynagh <igloo@earth.li>**20090717224100] 
[Allow mixed case in the LINE pragma; patch from squadette; fixes #1817
Ian Lynagh <igloo@earth.li>**20090717133522] 
[Comment only
simonpj@microsoft.com**20090717120154
 Ignore-this: f96b11e602fe4b311c1e466af9aa1908
] 
[Add missing case for eq_note.
t-peterj@microsoft.com**20090624134407] 
[Rename parameters to make debugging code compile.
t-peterj@microsoft.com**20090626105440] 
[Comment fix: use the same variable names in the conclusion as in the premise.
t-peterj@microsoft.com**20090618092235] 
[Use names like '$fOrdInt' for dfuns (and TF instances), rather than '$f21'
Simon Marlow <marlowsd@gmail.com>**20090716125643
 Ignore-this: d0b4632cf8ed9e05b67a19aa19ab3e19
 
 2 reasons for this:
   - compilation is more predictable.  Adding or removing an instance
     is less likely to force unnecessary recompilation due to
     renumbering other dfun names.
   - it makes it easier to read Core / C-- / asm
 
 The names aren't completely deterministic.  To do that, we'd have to
 include package and module names, which would make the symbol names
 long and reduce readability.  So the compromise is that if there's a
 clash, we disambiguate by adding an integer suffix.  This is fairly
 unlikely in practice unless you're using overlapping instances.
 
 Type family instances are handled in the same way, with the same
 disambiguation strategy.
] 
[Use a stable ordering for the export list in the interface
Simon Marlow <marlowsd@gmail.com>**20090716122601
 Ignore-this: 847dd7adc8b52e56f28d2478c78c925
 The export list was ordered according to the whim of FastStrings,
 which meant that interface fingerprints could change for no good
 reason, causing spurious recompilation.
] 
[whitespace only
Simon Marlow <marlowsd@gmail.com>**20090716104217
 Ignore-this: 38cff291d9ef15c30e3ed685ffc3c9f9
] 
[refactor: use packageConfigId in place of mkPackageId . package
Simon Marlow <marlowsd@gmail.com>**20090716104145
 Ignore-this: f3d73e7bd1b307a67d26585c49f3d89f
] 
[Typo fixes, from Alexey Mahotkin
Ian Lynagh <igloo@earth.li>**20090717010817] 
[Don't put all of $CFLAGS into $SRC_CC_OPTS
Ian Lynagh <igloo@earth.li>**20090716131309
 Instead, we just put the flags we need in there (e.g. -m64 on OS X 64).
 This fixes a problem found by Simon M, where we were compiling
 everything with -g, leading to a bloated RTS.
] 
[Move showOpt into DynFlags
Ian Lynagh <igloo@earth.li>**20090716005314] 
[Make the --info values printable with "ghc --print-foo"; trac #3122
Ian Lynagh <igloo@earth.li>**20090716001718
 Also, libdir is now part of the --info output, so this subsumes the old
 --print-libdir flag.
 The mode parsing was getting rather adhoc, so I've tidied it up a bit
 in the process.
] 
[Fix a flag name in the docs
Ian Lynagh <igloo@earth.li>**20090714165943] 
[Add the -fno-shared-implib flag
Ian Lynagh <igloo@earth.li>**20090714165631
 Patch from
     Max Bolingbroke <batterseapower@hotmail.com>
 Rerecorded to avoid conflicts.
] 
[Derived Foldable instances should use Data.Foldable.foldr
m.niloc@gmail.com**20090711130647
 Ignore-this: e3eb841e9535a842a98bb1ae0532c6e8
] 
[remove Solaris-specific hacks, now unnecessary
Simon Marlow <marlowsd@gmail.com>**20090713083524
 Ignore-this: 500077008e463532e0677ee82f5284bb
] 
[Simplify timestamp restoration
Matthias Kilian <kili@outback.escape.de>**20090711100244
 Ignore-this: 7eaede224befa6b5368c91b92366211
] 
[FIX #3272
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090714054559
 Ignore-this: 225fe4d82d4eed02e9b1377687661bac
] 
[Fix warnings
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20090713092032
 Ignore-this: 3631b87164fc54d82e3a02875dc08f7d
] 
[Separate length from data in DPH arrays
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20090713044212
 Ignore-this: aa2cc3b5ae43bd2c493ce4b330c883cd
] 
[TFs: FIX #2203 (second half)
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090710064834
 Ignore-this: 46a46feaa73f74feb08524b9e7547414
] 
[TFs: Fix should_compile/Simple8
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090710042728
 Ignore-this: 471ab67e3df1c5245921be5286a45f93
] 
[workaround new Cygwin bash CRLF behaviour
Simon Marlow <marlowsd@gmail.com>**20090709132850
 Ignore-this: 5cfa2cc9d776ebe315c0f6ad7ab56d98
] 
[Use /usr/bin/test if it exists, and fix test syntax.
Simon Marlow <marlowsd@gmail.com>**20090709124616
 Ignore-this: 83a75ba7c3ce2a1d02bddb7bfe414bfe
 Should fix Solaris build failures
] 
[Stop using -fno-warn-unused-do-bind when compiling the libraries
Ian Lynagh <igloo@earth.li>**20090709160422
 They're now fixed to not generate those warnings
] 
[Remove maybePrefixMatch, using stripPrefix instead
Ian Lynagh <igloo@earth.li>**20090709160412
 We already require GHC 6.8 to build, and that included stripPrefix
 in Data.List.
] 
[Allow mixed case pragmas; #1817. Patch from squadette
Ian Lynagh <igloo@earth.li>**20090709153737
 This patch allow you to use "Language CPP", or even "LaNgUaGe CPP",
 if you wish, as the manual claims you can.
] 
[don't create inplace/bin/ghc-<version>
Simon Marlow <marlowsd@gmail.com>**20090706092031
 Ignore-this: 2584d7bf56e77b27ca5b7b557c152c5e
] 
[Fix ignored-monadic-result warnings
Ian Lynagh <igloo@earth.li>**20090707181857] 
[Fix an unused import warning
Ian Lynagh <igloo@earth.li>**20090707144706] 
[Avoid unnecessary recompilation after ./configure (helps #3228)
Simon Marlow <marlowsd@gmail.com>**20090707085040
 Ignore-this: f8b3e7a2a96bc23cd29505ab9c8dbd7d
 We cache the old versions of files generated by configure, so that if
 configure touches the file without changing it, we can detect that and
 restore the timestamp.
] 
[check for tabs in compiler/ghc.cabal.in (#3344)
Simon Marlow <marlowsd@gmail.com>**20090707081845
 Ignore-this: 6073db47eafd52e13e76c58ef738afcf
] 
[remove tabs
Simon Marlow <marlowsd@gmail.com>**20090707081823
 Ignore-this: 3d65831fc019f76cefac03291904842a
] 
[fix cleaning of libraries (now 'make clean' in libraries/* works again)
Simon Marlow <marlowsd@gmail.com>**20090703114638
 Ignore-this: b3af731d50ff5bfbd453f94aa40cb92c
] 
[FIX #2677
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090707055442
 Ignore-this: e224dd09d0d1c9ec4f3b46c7accb8d57
] 
[Fix unused import warnings
Ian Lynagh <igloo@earth.li>**20090707143216] 
[Fix unused import warnings
Ian Lynagh <igloo@earth.li>**20090707133537] 
[When exporting F(..), all the children of F are also exported
Ian Lynagh <igloo@earth.li>**20090707133427
 This fixes the unused imports warning when
     Foo (F(x,y,z))
 is imported and
     Foo (F(..))
 is exported.
] 
[Remove unused imports
Ian Lynagh <igloo@earth.li>**20090707121548] 
[Major patch to fix reporting of unused imports
simonpj@microsoft.com**20090706112503
 Ignore-this: 3b5ecdd880474493d73bdbdc0fa0b782
 
 This patch, joint work between and Ian and Simon, fixes Trac #1074
 by reporting unused import declarations much more accuratly than 
 before.  The specification is described at 
 
 http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
 
 The implementation is both easier to understand than before, and shorter
 too.  
 
 Also fixed are #1148, #2267
 
 Also fixed is -ddump-minimal imports, which now works properly, fixing 
 Trac #1792.
 
 
] 
[Trim unused imports detected by new unused-import code
simonpj@microsoft.com**20090706112201
 Ignore-this: c6ca46d3a750c1cd1d58ea2c0de9f14f
] 
[Fix generational GC bug (#3348)
Simon Marlow <marlowsd@gmail.com>**20090706112227
 Ignore-this: 5938338efa0ad1550968c664a5a76f31
] 
[Windows fixes to build system: use the 'find' and 'sort' found by configure
simonpj@microsoft.com**20090706103413
 Ignore-this: a96197917f388a637118bafefb427495
 
 The build system should use 'find' and 'sort' that are discovered by
 configure, not the ones in your path.  On Windows the ones in your path
 might well be the non-Unixy Windows versions.
 
 This patch fixes the ones I tripped over. There may be more.
 
] 
[Update driver/Makefile for the new build system
Ian Lynagh <igloo@earth.li>**20090705204041] 
[Follow Cabal changes
Ian Lynagh <igloo@earth.li>**20090705180414] 
[Update TODO list
Ian Lynagh <igloo@earth.li>**20090705165009] 
[Make -fext-core a dynamic flag (it was a static flag)
Ian Lynagh <igloo@earth.li>**20090705132420] 
[Update a few points about shared libs in other sections
Duncan Coutts <duncan@well-typed.com>**20090704212212
 And add links to the new shared libs section.
] 
[Document -dynload flag. Also add it and -shared to the flags reference.
Duncan Coutts <duncan@well-typed.com>**20090704212119] 
[Add new section on using shared libs
Duncan Coutts <duncan@well-typed.com>**20090704212003] 
[Document foreign import prim in the user guide
Duncan Coutts <duncan@well-typed.com>**20090704180547
 Basically just stat that it exists and refer to the ghc dev wiki
 for the details, because we don't really want people using it.
] 
[For now, use -fno-warn-unused-do-bind when building the libraries
Ian Lynagh <igloo@earth.li>**20090704210654] 
[Make changes to -fwarn-unused-do-bind and -fwarn-wrong-do-bind suggested by SPJ
Max Bolingbroke <batterseapower@hotmail.com>**20090702150943
 Ignore-this: 595368298d2e11623c0bd280ff89d8de
] 
[Support for -fwarn-unused-do-bind and -fwarn-wrong-do-bind, as per #3263
Max Bolingbroke <batterseapower@hotmail.com>**20090701200344
 Ignore-this: 511117ffc10d4b656e530b751559b8b8
] 
[Improved infrastructure for fast-rebuilding of parts of the tree
Simon Marlow <marlowsd@gmail.com>**20090703074527
 Ignore-this: ab348d0988d8bbc28c2b4babbd6bbfb8
 
 e.g.
 
   cd compiler
   make FAST=YES stage1/build/HscTypes.o
 
 builds just the specified .o file, without rebuilding dependencies,
 and omitting some of the makefile phases.  FAST=YES works anywhere, to
 omit depenencies and phases.  'make fast' is shorthand for 'make
 all FAST=YES'.
] 
[Fix Trac #3342: missed zonking in TcHsSyn
simonpj@microsoft.com**20090702124331
 Ignore-this: 9b97b2142dfc665b503f59df7c55dd17
 
 The type in a ViewPat wasn't being zonked.  Easily fixed.
 
] 
[Type synonym families may be nullary
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090702084826
 Ignore-this: bcfe6ed62c901206daf5a5088890bbea
] 
[New syntax for GADT-style record declarations, and associated refactoring
simonpj@microsoft.com**20090702094657
 Ignore-this: bd9817230d3773b3b01fae3d7f04c57d
 
 The main purpose of this patch is to fix Trac #3306, by fleshing out the
 syntax for GADT-style record declraations so that you have a context in 
 the type.  The new form is
    data T a where
      MkT :: forall a. Eq a => { x,y :: !a } -> T a
 See discussion on the Trac ticket.
 
 The old form is still allowed, but give a deprecation warning.
 
 When we remove the old form we'll also get rid of the one reduce/reduce
 error in the grammar. Hurrah!
 
 While I was at it, I failed as usual to resist the temptation to do lots of
 refactoring.  The parsing of data/type declarations is now much simpler and
 more uniform.  Less code, less chance of errors, and more functionality.
 Took longer than I planned, though.
 
 ConDecl has record syntax, but it was not being used consistently, so I
 pushed that through the compiler.
 
] 
[White space only
simonpj@microsoft.com**20090702094627
 Ignore-this: 19f654cbf371c8dcc6517fd4934855b4
] 
[Comments only
simonpj@microsoft.com**20090702094531
 Ignore-this: 384fc2729c7c50a1680775a1f9ff89e4
] 
[Look through Notes when matching
simonpj@microsoft.com**20090702094444
 Ignore-this: 7daea81e905ec6061d3e0fd588d7e61b
] 
[FIX #3197
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090702070905
 Ignore-this: ebf829f0ae025e82bccdfa4345828ffe
] 
[Fix #2197 (properly this time)
Simon Marlow <marlowsd@gmail.com>**20090701122354
 Ignore-this: 39b6e4b0bcdd8c2f4660f976b7db768d
 
 $ ./inplace/bin/ghc-stage2 --interactive
 GHCi, version 6.11.20090701: http://www.haskell.org/ghc/  :? for help
 ghc-stage2: GHCi cannot be used when compiled with -prof
 [1]    32473 exit 1     ./inplace/bin/ghc-stage2 --interactive
] 
[make GhcProfiled work, and add a "prof" flavour to build.mk
Simon Marlow <marlowsd@gmail.com>**20090701114211
 Ignore-this: 386d347e4ad8b6c2bd40a2ba7da31ba6
 
 Building a profiled GHC is as simple as adding
 
 GhcLibWays += p
 GhcProfiled = YES
 
 to your build.mk and saying 'make'.  Then you have a profiled
 inplace/bin/ghc-stage2.
] 
[remove unnecessary $(RM)s
Simon Marlow <marlowsd@gmail.com>**20090701110609
 Ignore-this: f326ec8931d0d484a66b67ce1270cc6e
] 
['make html' in a library builds the Haddock docs
Simon Marlow <marlowsd@gmail.com>**20090630111137
 Ignore-this: 781bf10e2d4bca23b7f70c6f0465d120
] 
[fix GC bug introduced with the C finalizer support
Simon Marlow <marlowsd@gmail.com>**20090630080834
 Ignore-this: 3567e3adb5ae4a5dcbce81733487f348
] 
[Fix #3319, and do various tidyups at the same time
Simon Marlow <marlowsd@gmail.com>**20090626095421
 Ignore-this: ea54175f6bd49e101d7b33392764f643
  - converting a THSyn FFI declaration to HsDecl was broken; fixed
  - pretty-printing of FFI declarations was variously bogus; fixed
  - there was an unused "library" field in CImport; removed
] 
[rename cache variable to keep recent autoconfs happy
Ross Paterson <ross@soi.city.ac.uk>**20090626131410
 Ignore-this: 187091bbe78f2b14402162acfb98180f
] 
[TAG 2009-06-25
Ian Lynagh <igloo@earth.li>**20090625155528] 
[TAG 2009-06-25
Ian Lynagh <igloo@earth.li>**20090625155514] 
[Add a configure test for whether or not __mingw_vfprintf exists
Ian Lynagh <igloo@earth.li>**20090627150501] 
[Add buildinfo files to the bindist
Ian Lynagh <igloo@earth.li>**20090625132220] 
[Fix Trac #3323: naughty record selectors again
simonpj@microsoft.com**20090625072340
 Ignore-this: 5ea70e631a2104ae7bf139f89a91a63a
 
 I boobed when I decoupled record selectors from their data types.
 The most straightforward and robust fix means attaching the TyCon
 of a record selector to its IfaceIdInfo, so 
 
    you'll need to rebuild all .hi files
 
 That said, the fix is easy.
 
] 
[propagate the result of atomically properly (fixes #3049)
Simon Marlow <marlowsd@gmail.com>**20090624141530
 Ignore-this: 419d29c24d280799e44ee8248f27c606
] 
[add debug_p and thr_debug_p to $(ALL_WAYS)
Simon Marlow <marlowsd@gmail.com>**20090624110255
 Ignore-this: 6f4aebb8b276b8ec5d77ae6a809b0a6b
] 
[Fix buffering problem when GHCi is using the new IO library
Simon Marlow <marlowsd@gmail.com>**20090623142623
 Ignore-this: 54c78173244203852e27156df139c9f0
 Behind the scenes, the new IO library always does buffering for read
 Handles regardless of NoBuffering.  Normally this isn't visible, but
 it causes a problem in GHCi where there are two stdin Handles.
 
 This should fix those ghci test failures that sprung up in full
 testsuite runs recently.
] 
[Optimise the %.hi : %.o rule
Simon Marlow <marlowsd@gmail.com>**20090623124901
 Ignore-this: 4c467d6b7ae90243429951a4f54ff027
 Previously this rule had a sanity check for the existence of the .o
 file.  However, the sanity check is expensive, especially on Windows,
 because it requires spawning a shell.  So now we use an empty command
 here.
 
 This change reduced the time to do 'make' in an up-to-date tree on
 Windows from 33s to 16s for me.  (the actual saving depends on how
 much rebuilding you've been doing, and how many .hi files are older
 than their .o files).
 
 The comments in this file now describe various versions of the rule
 that don't work.
] 
[fix comment
Simon Marlow <marlowsd@gmail.com>**20090622145249
 Ignore-this: 17950b7877d90170ea3fd12f98a9fe02
] 
[Make C and CMM objects way-dependent
Ian Lynagh <igloo@earth.li>**20090624134531
 In particular, in the integer-gmp package the C and CMM code depends
 on the size of STG structures, which vary between ways.
] 
[Add boot-pkgs and packages to the source dists
Ian Lynagh <igloo@earth.li>**20090623224516] 
[follow change in System.Posix.Internals.c_open
Simon Marlow <marlowsd@gmail.com>**20090622140724
 Ignore-this: 1cc3370defcfbbd2ccec1f6aba193e6
] 
[fix 'make 1'
Simon Marlow <marlowsd@gmail.com>**20090617140657
 Ignore-this: 16ba87f7ffc7dd8bd4b738ed9f843687
] 
[remove unused cruft
Simon Marlow <marlowsd@gmail.com>**20090603143348
 Ignore-this: 4daebb56f61c4391823c12a2705135
] 
[Fix the GHCi debugger so that it can recognise Integers again
Ian Lynagh <igloo@earth.li>**20090623001946] 
[Follow Integer changes
Ian Lynagh <igloo@earth.li>**20090622224423] 
[Add the integer package
Ian Lynagh <igloo@earth.li>**20090622221716
 integer-gmp's Integer is now wrapped by an Integer type in integer.
] 
[Add a couple more symbols to the Linker.c table
Ian Lynagh <igloo@earth.li>**20090622144443
 Fixes ghci loading gmp on Windows
] 
[The IO type has moved to GHC.Types in ghc-prim
Ian Lynagh <igloo@earth.li>**20090620155154] 
[Fix #3132: a case of bogus code generation
Simon Marlow <marlowsd@gmail.com>**20090618090718
 Ignore-this: 7c9f7d649ea6baf9422c97f6c95ecc81
] 
[Fix the way in the +RTS --info output
Ian Lynagh <igloo@earth.li>**20090620142600] 
[Set DELETE_ON_ERROR in ghc.mk
Ian Lynagh <igloo@earth.li>**20090617121806] 
[makefile tweak
Ian Lynagh <igloo@earth.li>**20090617121711] 
[Add an _EXTRA_OBJS variable when linking packages
Ian Lynagh <igloo@earth.li>**20090616231750] 
[Fix the ghci wrapper
Ian Lynagh <igloo@earth.li>**20090616182501
 The ${1+"$@"} was being evaluated by make, rather than being escaped.
] 
[Remove more GMP bits
Ian Lynagh <igloo@earth.li>**20090616173712] 
[Add a #endif back that was accidentally removed from package.conf.in
Ian Lynagh <igloo@earth.li>**20090616170417] 
[Fix #3279, #3288: fix crash encountered when calling unblock inside unsafePerformIO
Simon Marlow <marlowsd@gmail.com>**20090616152455
 Ignore-this: 79b89712df9f87b239c41e469c8745c8
 See comments for details
] 
[drop packedstring; it is no longer required by template-haskell
Simon Marlow <marlowsd@gmail.com>**20090518120957
 Ignore-this: bd2e52eac8372b53a65e9dbd0d8ae46f
] 
[suggest "cd <dir>; make help"
Simon Marlow <marlowsd@gmail.com>**20090616085708
 Ignore-this: 4ea0fcb9ab613b1b29daaf4881f8edb6
] 
[Add support for 'make help' in subdirectories
Simon Marlow <marlowsd@gmail.com>**20090616085341
 Ignore-this: 7a3f80690e8e9a9094096aa4cfecfa8b
 Including help for directory-specific targets, such as 'make 1' in ghc
] 
[mention 'make {html,ps,pdf}'
Simon Marlow <marlowsd@gmail.com>**20090616085302
 Ignore-this: af8e9abe23a903a14e99711b631abc1d
] 
[eliminate "warning: overriding commnds..." from make when we're cleaning
Simon Marlow <marlowsd@gmail.com>**20090616084451
 Ignore-this: 1ac620ad71d6e89313f544be1d94f6c3
] 
[Add 'make help', displaying a list of useful make targets
Simon Marlow <marlowsd@gmail.com>**20090615140008
 Ignore-this: e6aae72e011eb668bbb2cff677c11a02
] 
[Add 'make fast' which omits deps (for a library) and some of the phases
Simon Marlow <marlowsd@gmail.com>**20090615135801
 Ignore-this: ec6f7a63fbfd4d6881f0dc2931705da9
] 
[add the missing final row of dashes in the success message
Simon Marlow <marlowsd@gmail.com>**20090615135716
 Ignore-this: c173af64e8bfb4e50e2fa377c44031d8
] 
['make 1' in libraries builds just the stage1 libs
Simon Marlow <marlowsd@gmail.com>**20090615135651
 Ignore-this: 50d35c045f56575de99c4c8a644bd538
 i.e. not dph, and hence not stage2
] 
[add 'make stage1_libs', to make just the stage 1 libs
Simon Marlow <marlowsd@gmail.com>**20090615135532
 Ignore-this: 5bf5f3ff554f47fd6e22dd13a1729c2d
 i.e. not dph, and hence not the stage 2 compiler.
] 
[Make sure we aren't passing -Werror in the CFLAGS for configure scripts
Ian Lynagh <igloo@earth.li>**20090615214758
 When configure tests for a feature it may not generate warning-free C
 code, and thus may think that the feature doesn't exist if -Werror is
 on.
] 
[copyFileWithHeader: use binary Handles
Simon Marlow <marlowsd@gmail.com>**20090615110545
 Ignore-this: ae9bb5087317a20b9caefec9419c4a69
 Fixes failure when Haddocking Data.Monoid in libraries/base
] 
[Pass CFLAGS and LDFLAGS to configure scripts
Ian Lynagh <igloo@earth.li>**20090615201604] 
[.cmm rules need to depend on $$($1_$2_HC_DEP), not $$($1_$2_HC)
Ian Lynagh <igloo@earth.li>**20090615133357] 
[Move gmp into libraries/integer-gmp
Ian Lynagh <igloo@earth.li>**20090614183150] 
[Stop building the rts against gmp
Duncan Coutts <duncan@well-typed.com>**20090613191956
 Nothing from gmp is used in the rts anymore.
] 
[Remove the implementation of gmp primops from the rts
Duncan Coutts <duncan@well-typed.com>**20090613191851] 
[Stop setting the gmp memory functions in the rts
Duncan Coutts <duncan@well-typed.com>**20090613165841
 and remove the implementations of stg(Alloc|Realloc|Dealloc)ForGMP
] 
[Remove the gmp/Integer primops from the compiler
Duncan Coutts <duncan@well-typed.com>**20090613142410
 The implementations are still in the rts.
] 
[Put the CMM objects in the GHCi library too
Ian Lynagh <igloo@earth.li>**20090611162038] 
[Add rules for building .cmm files in libraries
Ian Lynagh <igloo@earth.li>**20090611134057] 
[Exports a few rts things we need for cmm code in external packages
Duncan Coutts <duncan@well-typed.com>**20090613170622
 In particular we need alloc_blocks and alloc_blocks_lim for MAYBE_GC.
 The gmp cmm primops also use stg_ARR_WORDS_info.
] 
[Add and export rts_unsafeGetMyCapability from rts
Duncan Coutts <duncan@well-typed.com>**20090612114156
 We need this, or something equivalent, to be able to implement
 stgAllocForGMP outside of the rts. That's because we want to use
 allocateLocal which allocates from the given capability without
 having to take any locks. In the gmp primops we're basically in
 an unsafe foreign call, that is a context where we hold a current
 capability. So it's safe for us to use allocateLocal. We just
 need a way to get the current capability. The method to get the
 current capability varies depends on whether we're using the
 threaded rts or not. When stgAllocForGMP is built inside the rts
 that's ok because we can do it conditionally on THREADED_RTS.
 Outside the rts we need a single api we can call without knowing
 if we're talking to a threaded rts or not, hence this addition.
] 
[Require GHCForeignImportPrim for "foreign import prim"
Duncan Coutts <duncan@well-typed.com>**20090611202647
 In practise currently you also need UnliftedFFITypes, however
 the restriction to just unlifted types may be lifted in future.
] 
[Add missing StgPrimCallOp case in repCCallConv
Duncan Coutts <duncan@well-typed.com>**20090611165905
 We don't handle "foreign import prim" in TH stuff. 
] 
[Add missing StgPrimCallOp case to isSimpleOp
Ian Lynagh <igloo@earth.li>**20090611122727] 
[Reverse the safe/unsafe requirement on foreign import prim
Duncan Coutts <duncan@well-typed.com>**20090611115243
 The safe/unsafe annotation doesn't currently mean anything for prim.
 Just in case we decide it means something later it's better to stick
 to using one or the other consistently. We decided that using safe
 is the better one to require (and it's also the default).
] 
[Add PrimCall to the STG layer and update Core -> STG translation
Duncan Coutts <duncan@well-typed.com>**20090609151155
 It adds a third case to StgOp which already hold StgPrimOp and StgFCallOp.
 The code generation for the new StgPrimCallOp case is almost exactly the
 same as for out-of-line primops. They now share the tailCallPrim function.
 In the Core -> STG translation we map foreign calls using the "prim"
 calling convention to the StgPrimCallOp case. This is because in Core we
 represent prim calls using the ForeignCall stuff. At the STG level however
 the prim calls are really much more like primops than foreign calls.
] 
[Desugaring for "foreign import prim"
Duncan Coutts <duncan@well-typed.com>**20090609105945
 Unlike normal foreign imports which desugar into a separate worker and
 wrapper, we use just a single wrapper decleration. The representation
 in Core of the call is currently as a foreign call. This means the
 args are all treated as fully strict. This is ok at the moment because
 we restrict the types for foreign import prim to be of unboxed types,
 however in future we may want to make prim imports be the normal cmm
 calling convention for Haskell functions, in which case we would not
 be able to assume all args are strict. At that point it may make more
 sense to represent cmm/prim calls distinct from foreign calls, and
 more like the we the existing PrimOp calls are handled.
] 
[Typechecking for "foreign import prim"
Duncan Coutts <duncan@well-typed.com>**20090609104826
 The main restriction is that all args and results must be unboxed types.
 In particular we allow unboxed tuple results (which is a primary
 motivation for the whole feature). The normal rules apply about
 "void rep" result types like State#. We only allow "prim" calling
 convention for import, not export. The other forms of import, "dynamic",
 "wrapper" and data label are banned as a conseqence of checking that the
 imported name is a valid C string. We currently require prim imports to
 be marked unsafe, though this is essentially arbitrary as the safety
 information is unused.
] 
[Lexing and parsing for "foreign import prim"
Duncan Coutts <duncan@well-typed.com>**20090609104536
 We only allow simple function label imports, not the normal complicated
 business with "wrapper" "dynamic" or data label "&var" imports.
] 
[Add new FFI calling convention "prim"
Duncan Coutts <duncan@well-typed.com>**20090609104403
 First in a series of patches to add the feature.
 This patch just adds PrimCallConv to the CCallConv type.
] 
[Include runghc and unlit in bindists
Ian Lynagh <igloo@earth.li>**20090613161707] 
[Improve bindist testing
Ian Lynagh <igloo@earth.li>**20090613161516
 We now also test runghc and unlit
] 
[Remove the haskeline-specific hacks from ghc-cabal
Ian Lynagh <igloo@earth.li>**20090612235823
 Now that base does -liconv when it is necessary, it is no longer
 necessary for haskeline to do it as well, as haskeline depends on base.
 Thus we don't need the haskeline-specific hacks in ghc-cabal any more.
] 
[Remove library buildinfo files when cleaning
Ian Lynagh <igloo@earth.li>**20090612233818] 
[Update symbol names; fixes the build on OSX
Ian Lynagh <igloo@earth.li>**20090612194029] 
[don't check for stack underflow if we just had an overflow
Simon Marlow <marlowsd@gmail.com>**20090610104748
 Ignore-this: 1c52dd362ec23bdec26012c23d5049e6
] 
[pprExpr: don't add extra parens around [a..b] in an argument position
Simon Marlow <marlowsd@gmail.com>**20090608082705
 Ignore-this: b0e25aa489a313535234571d9d8633a8
 test is tcfail205
] 
[Changes for the new IO library, mainly base-package modules moving around
Simon Marlow <marlowsd@gmail.com>**20090529131822
 Ignore-this: 7c542c1d82b18500118b8b198c9e2be0
] 
[Deprecate the threadsafe kind of foreign import
Duncan Coutts <duncan@well-typed.com>**20090611123441] 
[Remove __encodeDouble and __encodeFloat from the rts
Duncan Coutts <duncan@well-typed.com>**20090611154852
 They now live in the integer-gmp package.
] 
[Add recently added lib dirs to the darcs boring file
Duncan Coutts <duncan@well-typed.com>**20090611112824] 
[Fix the compiler-hs-dependency's
Ian Lynagh <igloo@earth.li>**20090612104827
 We needed some more $s to delay evaluation until the values are
 available, and the calls needed to be later in the ghc.mk so that
 compiler_stage2_WAYS etc are defined.
] 
[Doc building is now controlled by sensible variables
Ian Lynagh <igloo@earth.li>**20090611162858] 
[HC bootstrapping now works
Ian Lynagh <igloo@earth.li>**20090611162756] 
[bindists are now done
Ian Lynagh <igloo@earth.li>**20090611162730] 
[Add some $s to rules/build-package.mk for consistency
Ian Lynagh <igloo@earth.li>**20090611130144] 
[Fix the flag used to force linking when we are making a shared library
Duncan Coutts <duncan@well-typed.com>**20090604121652
 This is a correction to the patch:
 * When linking a shared library with --make, always do the link step
 which used the wrong flag in making the decision. It used -dynamic
 whereas the correct flag is -shared.
] 
[Check we're not using stdcall in foreign export on unsupported platforms
Duncan Coutts <duncan@well-typed.com>**20090608145509
 It's already checked for foreign import, but was missing for export.
] 
[Remove the various mp registers from the StgRegTable
Duncan Coutts <duncan@well-typed.com>**20090610173609
 No longer need them as temp vars in the cmm primop implementations.
] 
[Convert the gmp cmm primops to use local stack allocation
Duncan Coutts <duncan@well-typed.com>**20090610173026
 Using global temp vars is really ugly and in the threaded case it
 needs slots in the StgRegTable. It'd also be pretty silly once we
 move the cmm primops out of the rts, into the integer-gmp package.
] 
[Make killThread# cmm primop use local stack allocation
Duncan Coutts <duncan@well-typed.com>**20090610172215
 It using the mp_tmp_w register/global as a convenient temporary
 variable. This is naughty because those vars are supposed to be
 for gmp. Also, we want to remove the gmp temp vars so we must
 now use a local stack slot instead.
] 
[Make Windows bindists and installers work in the new build system
Ian Lynagh <igloo@earth.li>**20090610181825] 
[Change GHC_OPTIONS to OPTIONS_GHC
Ian Lynagh <igloo@earth.li>**20090610124611] 
[Define _BSD_SOURCE in Stg.h
Ian Lynagh <igloo@earth.li>**20090609121705
 This means that, on Linux, we get functions like gamma defined when we
 #include math.h
] 
[Put "%expect 0" directives in the .y files
Ian Lynagh <igloo@earth.li>**20090608203935
 With the exception of GHC's main Parser.y(.pp), which has 2
 reduce/reduce conflicts
] 
[Mention that generalised list comprehensions are enabled with -XTransformListComp
simonpj@microsoft.com**20090605140009
 Ignore-this: 4cb8b8153a2b072904c97a3bdd1ce05e
] 
[Update to libffi 3.0.8; fixes trac #3119
Ian Lynagh <igloo@earth.li>**20090605171704] 
[Fix the libffi Makefile
Ian Lynagh <igloo@earth.li>**20090605160538] 
[Add a README saying where libffi tarballs come from
Ian Lynagh <igloo@earth.li>**20090605160431] 
[ghc-pkg now takes a verbosity argument
Ian Lynagh <igloo@earth.li>**20090605151544] 
[Follow Cabal changes
Ian Lynagh <igloo@earth.li>**20090605131324] 
[Update the docs on how you bind unlifted types in let/where clauses
Ian Lynagh <igloo@earth.li>**20090605122929] 
[Document -fwarn-lazy-unlifted-bindings
Ian Lynagh <igloo@earth.li>**20090605122348] 
[Fix typo
Ian Lynagh <igloo@earth.li>**20090605122048] 
[Make a proper Opt_WarnLazyUnliftedBindings warning, with a flag etc
Ian Lynagh <igloo@earth.li>**20090605114316] 
[fix a warning
Simon Marlow <marlowsd@gmail.com>**20090604093539
 Ignore-this: 90713a7abf991d73c352cbd5a4012d5d
] 
[Lock the StablePtr table during GC
Simon Marlow <marlowsd@gmail.com>**20090604090553
 Ignore-this: 9e9705892b80a8226fd37df04d9c606d
 Allows hs_free_fun_ptr() to be called by a separate thread
] 
[fix $(TOP)
Simon Marlow <marlowsd@gmail.com>**20090604084824
 Ignore-this: abfe797881428381eebf6b2036a83a7c
] 
[remove a prototype that shouldn't be here
Simon Marlow <marlowsd@gmail.com>**20090604084749
 Ignore-this: a0fda8f38b5674fcfa04f30b01d4e846
] 
[Fix ghc-cabal, so that GHC.Prim gets registered when we install
Ian Lynagh <igloo@earth.li>**20090604124501] 
[Tighten up the DocBook XSL stylesheet test
Simon Marlow <marlowsd@gmail.com>**20090603101244
 Ignore-this: e68f96360250831634c77914afe11566
 It wasn't failing even when the DTD was not found.
] 
[fix logic for BUID_DOCBOOK_HTML
Simon Marlow <marlowsd@gmail.com>**20090603092313
 Ignore-this: f255bbaf00713b998370c810e7ab75d3
] 
[Allow RULES for seq, and exploit them
simonpj@microsoft.com**20090603092956
 Ignore-this: 7d72898475a3a76fea48c9a85ea2dfd
 
 Roman found situations where he had
       case (f n) of _ -> e
 where he knew that f (which was strict in n) would terminate if n did.
 Notice that the result of (f n) is discarded. So it makes sense to
 transform to
       case n of _ -> e
 
 Rather than attempt some general analysis to support this, I've added
 enough support that you can do this using a rewrite rule:
 
   RULE "f/seq" forall n.  seq (f n) e = seq n e
 
 You write that rule.  When GHC sees a case expression that discards
 its result, it mentally transforms it to a call to 'seq' and looks for
 a RULE.  (This is done in Simplify.rebuildCase.)  As usual, the
 correctness of the rule is up to you.
 
 This patch implements the extra stuff.  I have not documented it explicitly
 in the user manual yet... let's see how useful it is first.
 
 The patch looks bigger than it is, because
   a) Comments; see esp MkId Note [seqId magic]
 
   b) Some refactoring.  Notably, I moved the special desugaring for
      seq from MkCore back into DsUtils where it properly belongs.
      (It's really a desugaring thing, not a CoreSyn invariant.)
 
   c) Annoyingly, in a RULE left-hand side we need to be careful that
      the magical desugaring done in MkId Note [seqId magic] item (c) 
      is *not* done on the LHS of a rule. Or rather, we arrange to 
      un-do it, in DsBinds.decomposeRuleLhs.
 
 
] 
[Remove old GUM/GranSim code
Simon Marlow <marlowsd@gmail.com>**20090602140233
 Ignore-this: 9c03eaaf072122118fa4d9cb6db684ca
] 
[tidy up autoconfiguration of docbook stuff
Simon Marlow <marlowsd@gmail.com>**20090602134943
 Ignore-this: 967773e506bb00fe19c08831fb4e03a6
 
  * use --nonet, so xmllint and co don't go off trying to download
    stuff from the web
 
  * use the http:// reference for the stylesheet, so we don't have to
    search the filesystem for it (should speedup ./configure)
] 
[fix 'make sdist'
Simon Marlow <marlowsd@gmail.com>**20090602121618
 Ignore-this: 79da188afd5a22368e645a88c51237f1
] 
[Fix Trac #3265: type operators in type/class declarations
simonpj@microsoft.com**20090602133706
 Ignore-this: 17bc1c59defa189311171155f36562ab
 
 We should accept these:
 
    data a :*: b = ....
 or
    data (:*:) a b = ...
 
 only if -XTypeOperators is in force.  And similarly class decls.
 
 This patch fixes the problem.  It uses the slightly-nasty OccName.isSymOcc,
 but the only way to avoid that is to cach the result in OccNames which seems
 overkill to us.
 
] 
[Merge the TODO lists in ghc.mk
Ian Lynagh <igloo@earth.li>**20090603121209] 
[Remove the unused remains of __decodeFloat
Ian Lynagh <igloo@earth.li>**20090602182211] 
[Add a comment about why RM and RM_OPTS are not in config.mk
Ian Lynagh <igloo@earth.li>**20090602124700] 
[Follow the change in RM's definition in distrib/Makefile-bin-vars.in
Ian Lynagh <igloo@earth.li>**20090602124644] 
[Add a section "Multi-threading and the FFI"
Simon Marlow <marlowsd@gmail.com>**20090602102352
 Ignore-this: 767a942fa119cd1ea2eb13584667ac27
 and collect all the information about multi-threaded FFI use into it.
] 
[emit a helpful message if you say 'make html' and BUILD_DOCBOOK_HTML=NO
Simon Marlow <marlowsd@gmail.com>**20090602095936
 Ignore-this: a50f9799cc1ff7a5b7e1b0d9386ca3ef
] 
[mention documentation tools in the summary; tidy up formatting
Simon Marlow <marlowsd@gmail.com>**20090602090345
 Ignore-this: 6227ba9fc0f97b3cf796785356a10b37
] 
[depend on mk/project.mk appropriately
Simon Marlow <marlowsd@gmail.com>**20090529151934
 Ignore-this: 17517fcc36b4cafc1c4337a356e4a88c
] 
[fix comment
Simon Marlow <marlowsd@gmail.com>**20090529113028
 Ignore-this: 1391a669e3d253b3174ffae0970eee89
] 
[Use -w when compiling libffi, to stop -Werror failures
Ian Lynagh <igloo@earth.li>**20090602113408] 
[Unquote a $(LN_S) in ghc/ghc.mk
Ian Lynagh <igloo@earth.li>**20090530233356] 
[$(XARGS) might include arguments, so don't quote it in makefiles
Ian Lynagh <igloo@earth.li>**20090530233133] 
[Quote commands that we run, so they work if there are space in their paths
Ian Lynagh <igloo@earth.li>**20090530220021
 I've also added some missing $s to some makefiles. These aren't
 technically necessary, but it's nice to be consistent.
] 
[Remove some redundant code from hi-rule.mk
Ian Lynagh <igloo@earth.li>**20090530193729] 
[make the clean_libraries target work, so you can "make clean" in libraries/
Ian Lynagh <igloo@earth.li>**20090530184750] 
[fix pprDynamicLinkerAsmLabel for Mac OS X x86_64
Austin Seipp <as@nijoruj.org>**20090523090901
 Ignore-this: 2cef271f4ca27315bd8b0df9c1bc4343
] 
[Make clean_libraries in the same way that we make all_libraries
Ian Lynagh <igloo@earth.li>**20090529180150] 
[Tweak mk/sub-makefile.mk
Ian Lynagh <igloo@earth.li>**20090529175748] 
[Implement -XMonoLocalBinds: a radical new flag
simonpj@microsoft.com**20090529131137
 Ignore-this: b52744bdde2e8ea52a9b6d4374a3e049
 
 The new flag -XMonoLocalBinds tells GHC not to generalise nested
 bindings in let or where clauses, unless there is a type signature,
 in which case we use it.  
 
 I'm thinking about whether this might actually be a good direction for
 Haskell go to in, although it seems pretty radical.  Anyway, the flag
 is easy to implement (look at how few lines change), and having it
 will allow us to experiement with and without.
 
 Just for the record, below are the changes required in the boot 
 libraries -- ie the places where.  Not quite as minimal as I'd hoped,
 but the changes fall into a few standard patterns, and most represent
 (in my opinion) sytlistic improvements.  I will not push these patches,
 however.
 
 == running darcs what -s --repodir libraries/base
 M ./Control/Arrow.hs -2 +4
 M ./Data/Data.hs -7 +22
 M ./System/IO/Error.hs +1
 M ./Text/ParserCombinators/ReadP.hs +1
 == running darcs what -s --repodir libraries/bytestring
 M ./Data/ByteString/Char8.hs -1 +2
 M ./Data/ByteString/Unsafe.hs +1
 == running darcs what -s --repodir libraries/Cabal
 M ./Distribution/PackageDescription.hs -2 +6
 M ./Distribution/PackageDescription/Check.hs +3
 M ./Distribution/PackageDescription/Configuration.hs -1 +3
 M ./Distribution/ParseUtils.hs -2 +4
 M ./Distribution/Simple/Command.hs -1 +4
 M ./Distribution/Simple/Setup.hs -12 +24
 M ./Distribution/Simple/UserHooks.hs -1 +5
 == running darcs what -s --repodir libraries/containers
 M ./Data/IntMap.hs -2 +2
 == running darcs what -s --repodir libraries/dph
 M ./dph-base/Data/Array/Parallel/Arr/BBArr.hs -1 +3
 M ./dph-base/Data/Array/Parallel/Arr/BUArr.hs -2 +4
 M ./dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Arrays.hs -6 +10
 M ./dph-prim-par/Data/Array/Parallel/Unlifted/Distributed/Combinators.hs -3 +6
 M ./dph-prim-seq/Data/Array/Parallel/Unlifted/Sequential/Flat/Permute.hs -2 +4
 == running darcs what -s --repodir libraries/syb
 M ./Data/Generics/Twins.hs -5 +18
 
 
] 
[don't shrink the stack smaller than the value set by +RTS -k<size>
Simon Marlow <marlowsd@gmail.com>**20090529090827
 Ignore-this: 4034b691895bc2fb3a1eaa2195a9ae31
] 
[Fix bug in previous change: allocate the correct size
Simon Marlow <marlowsd@gmail.com>**20090529090758
 Ignore-this: b591ad70cdaed2def46fb8d046f63539
] 
[Make haddocking depend on the library .a file
simonpj@microsoft.com**20090529084514
 Ignore-this: 233496beeea7a0ca0d8d21543c5050c7
 
 You can't Haddock a library until it's built. Previously that happened
 automatically because
   Haddock itself was built with stage2
   And all the libraries were built with stage1
 But now DPH is built with stage2, so Haddock can get to work too
 early.
 
 This patch adds the missing dependency (thanks to Simon M)
 
] 
[Fix Trac #3259: expose 'lazy' only after generating interface files
simonpj@microsoft.com**20090529072020
 Ignore-this: 3c762bda546981c4b4f01d28b8586ff8
 
 This patch fixes an insidious and long-standing bug in the way that
 parallelism is handled in GHC.  See Note [lazyId magic] in MkId.
 
 Here's the diagnosis, copied from the Trac ticket.  par is defined 
 in GHC.Conc thus:
 
     {-# INLINE par  #-}
     par :: a -> b -> b
     par  x y = case (par# x) of { _ -> lazy y }
 
     -- The reason for the strange "lazy" call is that it fools the
     -- compiler into thinking that pseq and par are non-strict in
     -- their second argument (even if it inlines pseq/par at the call
     -- site).  If it thinks par is strict in "y", then it often
     -- evaluates "y" before "x", which is totally wrong.
 
 The function lazy is the identity function, but it is inlined only
 after strictness analysis, and (via some magic) pretends to be
 lazy. Hence par pretends to be lazy too.
 
 The trouble is that both par and lazy are inlined into your definition
 of parallelise, so that the unfolding for parallelise (exposed in
 Parallelise.hi) does not use lazy at all. Then when compiling Main,
 parallelise is in turn inlined (before strictness analysis), and so
 the strictness analyser sees too much.
 
 This was all sloppy thinking on my part. Inlining lazy after
 strictness analysis works fine for the current module, but not for
 importing modules.
 
 The fix implemented by this patch is to inline 'lazy' in CorePrep,
 not in WorkWrap. That way interface files never see the inlined version.
 
 The downside is that a little less optimisation may happen on programs
 that use 'lazy'.  And you'll only see this in the results -ddump-prep
 not in -ddump-simpl.  So KEEP AN EYE OUT (Simon and Satnam especially).
 Still, it should work properly now.  Certainly fixes #3259.
 
 
] 
[Fix Trac #3262: suppress name-shadow warning for _names
simonpj@microsoft.com**20090528152359
 Ignore-this: 482ee7e5039987c53b2755c8f61f3fe
 
 Adopt Max's suggestion for name shadowing, by suppressing shadowing
 warnings for variables starting with "_".  A tiny bit of refactoring
 along the way.
 
] 
[don't call Haskeline to read input when stdin is not a terminal
Simon Marlow <marlowsd@gmail.com>**20090528152651
 Ignore-this: 3810fe8dff7e0a8b4ec013f47e33cc4c
] 
[Fix handling of R_SPARC_UA32 relocations in linker
Ben.Lippmeier@anu.edu.au**20090528080509
   These refer to unaligned locations that need to be written
   byte-at-a-time. This fixes the SPARC ghci failures in 
   the current head.
] 
[Document the fact that Template Haskell type splices work
simonpj@microsoft.com**20090528165443
 Ignore-this: a3817bd84645acbe3c83ad04bbff06c3
] 
[Improve printing of Orig RdrNames
simonpj@microsoft.com**20090528165215
 Ignore-this: a00c57daf826176dbec85402a7982ef4
 
 In Tempate Haskell -ddump-splices, the "after" expression is populated 
 with RdrNames, many of which are Orig things.  We used to print these
 fully-qualified, but that's a bit heavy.
 
 This patch refactors the code a bit so that the same print-unqualified
 mechanism we use for Names also works for RdrNames.  Lots of comments
 too, because it took me a while to figure out how it all worked again.
 
] 
[Print more nicely in -ddump-splices
simonpj@microsoft.com**20090528165039
 Ignore-this: ffa4855ac1e95e45a057acae85ca75db
 
 When you say -ddump-splices, the "before" expression is now 
 
         *renamed* but not *typechecked"
 
 Reason (a) less typechecking crap
        (b) data constructors after type checking have been
           changed to their *wrappers*, and that makes them
           print always fully qualified
 
] 
[Fix Trac #3261: make default types play nice with -Werror
simonpj@microsoft.com**20090528164900
 Ignore-this: c6167edcb5c537cb0f08151f649c3eb2
 
 The trial-and-error for type defaults was not playing nicely with
 -Werror. The fix is simple.
 
] 
[Adjust error message slightly
simonpj@microsoft.com**20090528164802
 Ignore-this: c21f2ef9064fcf22f00e962f53a5f97
] 
[White space only
simonpj@microsoft.com**20090528164727
 Ignore-this: 355873c67330176455bc7d698190d956
] 
[Remove type-ambiguous (fromIntegral 0)::Int, replacing it with just 0
simonpj@microsoft.com**20090528164525
 Ignore-this: f09a0e7a2b4de20867036b7c8ee6f1d2
 
 This unnecessary ambiguity has been there for ages, and is now rejected
 by -Werror, after fixing #3261
 
] 
[Move getMainFun to TcRnDriver, trim DynFlags imports
simonpj@microsoft.com**20090528164436
 Ignore-this: a0cf27e74a916c13c4df77190d2e14b0
] 
[Comments only
simonpj@microsoft.com**20090528164329
 Ignore-this: 69b8edd4c3f8643ec9774a0f88af2c66
] 
[Comments about naming for data constructors
simonpj@microsoft.com**20090528164250
 Ignore-this: 8c31cbf597211b318dab96f3c728ac71
] 
[Remove dead code isHsVar
simonpj@microsoft.com**20090528092750
 Ignore-this: b19c8eb9f507e68d910515600a336e1c
] 
[Round stack size to a whole number of megablocks
Simon Marlow <marlowsd@gmail.com>**20090528133440
 Ignore-this: 6d7da9b80d7a6771365bd146201f102f
 This is not a bug fix, it just makes better use of memory
] 
[Fix #3156: ensure preconditions of splitLargeBlock()
Simon Marlow <marlowsd@gmail.com>**20090528133357
 Ignore-this: 5d7e7f345fe19123bf17aa1d2daa0e7b
] 
[fix it so that 'make' on its own works even if we're not building docs
Simon Marlow <marlowsd@gmail.com>**20090528111608
 Ignore-this: 92e9355de04733042403dc6814a3a146
] 
[Comments only
simonpj@microsoft.com**20090528075918
 Ignore-this: 14112a7b5e4d0b3b8763ce72d01bba00
] 
[Fix Trac #3013: multiple constructors in a GADT decl
simonpj@microsoft.com**20090528075306
 Ignore-this: fda39c50dd80e13d593e396133fd92c4
 
 Makes GADT syntax consistent by allowing multiple constructors
 to be given a single signature
    data T wehre
        A, B :: T
        C :: Int -> t
 
] 
[Separate flags -XDeriveFunctor, -XDeriveFoldable, -XDeriveTraversable
simonpj@microsoft.com**20090528075031
 Ignore-this: b5b6ce32b6d4e847a6f58de17dd1af54
 
 See Trac #2953. This patch implements a distinct flag for each extended
 class that may be automatically derived.  And I updated the user manual
 to reflect the fact that we can now derive Functor, Foldable, Traversable.
 
] 
[Add a comment
simonpj@microsoft.com**20090528072513
 Ignore-this: d278c8d49b299e376a8dbcdd940e1cfa
] 
[Follow vreg/hreg patch in X86_64 NCG
Ben.Lippmeier.anu.edu.au**20090527040101
 Ignore-this: f11f3d8ebfc33d3c012ce8d2cb09d076
] 
[Follow vreg/hreg patch in PPC NCG
Ben.Lippmeier@anu.edu.au**20090526105522] 
[Follow vreg/hreg patch in x86 NCG
Ben.Lippmeier@anu.edu.au**20090519095507
 Ignore-this: c4303cc12ddbdd38606c16a7e2fbc56c
] 
[Don't try and coalesce RealReg->RealReg moves
Ben.Lippmeier@anu.edu.au**20090519035528] 
[Split Reg into vreg/hreg and add register pairs
Ben.Lippmeier@anu.edu.au**20090518014444
 
  * The old Reg type is now split into VirtualReg and RealReg.
  * For the graph coloring allocator, the type of the register graph
    is now (Graph VirtualReg RegClass RealReg), which shows that it colors
    in nodes representing virtual regs with colors representing real regs.
    (as was intended)  
  * RealReg contains two contructors, RealRegSingle and RealRegPair,
    where RealRegPair is used to represent a SPARC double reg 
    constructed from two single precision FP regs. 
  * On SPARC we can now allocate double regs into an arbitrary register
    pair, instead of reserving some reg ranges to only hold float/double values. 
] 
[SPARC NCG: Fix available regs for graph allocator
Ben.Lippmeier@anu.edu.au**20090421014409] 
[Fix Trac #3221: renamer warnings for deriving clauses
simonpj@microsoft.com**20090527182157
 Ignore-this: a4a93f2928fd311c4950eb60277bf9e1
 
 This patch arranges to gather the variables used by 'deriving' clauses,
 so that unused bindings are correctly reported.
 
] 
[Template Haskell: allow type splices
simonpj@microsoft.com**20090527181242
 Ignore-this: 8beb8ab4f5857967ff33a4877c8931b
 
 At last!  Trac #1476 and #3177
 
 This patch extends Template Haskell by allowing splices in
 types.  For example
 
   f :: Int -> $(burble 3)
 
 A type splice should work anywhere a type is expected.  This feature
 has been long requested, and quite a while ago I'd re-engineered the
 type checker to make it easier, but had never got around to finishing
 the job.  With luck, this does it.
 
 There's a ToDo in the HsSpliceTy case of RnTypes.rnHsType, where I
 am not dealing properly with the used variables; but that's awaiting
 the refactoring of the way we report unused names.
 
 
 
] 
[Template Haskell: improve lifting for strings
simonpj@microsoft.com**20090527180840
 Ignore-this: 296fa4ede64a87cc66b8c7af0e35b66f
 
 When you have a (\s::String -> ....[| s |]....), the string 
 's' is lifted.  We used to get a chain of single-character 
 Cons nodes, correct but lots and lots of code.  
 
 This patch arranges to optimise that to a string literal. It does
 so in two places:
   a) In TcExpr, if we know that s::String, we generate liftString directly
   b) In DsMeta, if we find a list of character literals, we convert to
      a string.  This catches a few cases that (a) does not
 
 There an accompanying  patch in the template-haskell package, 
 adding Language.Haskell.TH.Syntax.liftString
 
 
 
] 
[Rename conDeclsNames to hsConDeclsNames, and export it
simonpj@microsoft.com**20090527180032
 Ignore-this: 304b8881445df43a7a98e17001500ba9
] 
[Comments about wiredInIds
simonpj@microsoft.com**20090527175603
 Ignore-this: 9f0910d37e75f7a91807a3b2e5b2d608
] 
[Wibble some comments to avoid haddock parse errors
Ian Lynagh <igloo@earth.li>**20090526192953] 
[Add a haddock target, for just building the haddock docs
Ian Lynagh <igloo@earth.li>**20090526190459] 
[Add some more $s to rules/haddock.mk for consistency
Ian Lynagh <igloo@earth.li>**20090526184127] 
[Fix haddocking
Ian Lynagh <igloo@earth.li>**20090526184034
 We were looking at HADDOCK_DOCS instead of $$(HADDOCK_DOCS)
] 
[Make the sed in configure.ac more portable
Ian Lynagh <igloo@earth.li>**20090525120021] 
[Remove legacy code that isn't used now that we require GHC >= 6.8
Ian Lynagh <igloo@earth.li>**20090524204412] 
[Remove unused variables
Ian Lynagh <igloo@earth.li>**20090524135350] 
[Remove unused variables
Ian Lynagh <igloo@earth.li>**20090524134753] 
[Be more precise about munging compiler/stage1/inplace-pkg-config
Ian Lynagh <igloo@earth.li>**20090524133439
 We were removing ".$(ProjectPatchLevel)" from anywhere in the file.
 However, it included absolute paths, so if you untar a source
 tarball into its default directory name, e.g.
 "6.11.$(ProjectPatchLevel)", then the sed would break the paths.
] 
[Use the more portable %lu rather than %zu
Ian Lynagh <igloo@earth.li>**20090524131504
 We now also need to cast the values to (unsigned long), as on some
 platforms sizeof returns (unsigned int).
] 
[Clean libraries/bootstrapping.conf
Ian Lynagh <igloo@earth.li>**20090524131454] 
[Fix warnings
Ian Lynagh <igloo@earth.li>**20090523231438] 
[Fix warnings in genprimopcode
Ian Lynagh <igloo@earth.li>**20090523222715] 
[Fix warnings in mkDerivedConstants
Ian Lynagh <igloo@earth.li>**20090523215836] 
[Fix warnings in ghc-cabal
Ian Lynagh <igloo@earth.li>**20090523213518] 
[Turn on warnings when validating
Ian Lynagh <igloo@earth.li>**20090523213451] 
[Fix configure
Ian Lynagh <igloo@earth.li>**20090523004231] 
[ghc_ge_607 is now always true
Ian Lynagh <igloo@earth.li>**20090523001643] 
[Sanity check the platforms we are given
Ian Lynagh <igloo@earth.li>**20090523000445] 
[Change how we find the host/build/target platforms
Ian Lynagh <igloo@earth.li>**20090522233022
 Rather than using the autoconf built-in stuff and mangling it, we
 now just ask the bootstrapping compiler what platform we are on.
 
 When doing a port of GHC, you need to specify the platform you are
 porting to.
 
 The minimum version of GHC required is now 6.8.
] 
[remove old todo comment
Simon Marlow <marlowsd@gmail.com>**20090520224427
 Ignore-this: 7dc72333d7f84d12a581514da368caa7
] 
[document -XUnicodeSyntax
Simon Marlow <marlowsd@gmail.com>**20090520223647
 Ignore-this: 343d54ebf27013c21e5dea1e8aab2740
] 
[export sysErrorBelch
Simon Marlow <marlowsd@gmail.com>**20090328191355] 
[ rm package.conf.inplace in distclean, not clean
Simon Marlow <simonmar@microsoft.com>**20090506195216] 
[#2197: try to detect when GHCi is compiled with -prof and emit an error message
Simon Marlow <simonmar@microsoft.com>**20090506194802] 
[fix typo
Simon Marlow <simonmar@microsoft.com>**20090328211518] 
[Remove hacky on-demand building of libraries/*/ghc.mk, put it back in sh boot
Simon Marlow <marlowsd@gmail.com>**20090522083351
 Ignore-this: fa8ada7f782776613aafc5a2825452f0
 Now that the clean rules don't require libraries/*/ghc.mk, we don't
 have to build them on demand.  And having them built on demand
 introduced a failure mode (where some libraries have ghc.mk and some
 don't).
] 
[Fix unregisterised bindists
Ian Lynagh <igloo@earth.li>**20090521223519] 
[Pass CFLAGS and LDFLAGS to libffi's configure
Ian Lynagh <igloo@earth.li>**20090521160210] 
[Don't overwrite the *OPTS/*Opts variables in mk/validate-settings.mk
Ian Lynagh <igloo@earth.li>**20090521141938
 Overwriting means we lose the -m64 on OS X 64.
] 
[Build and install gmp.h
Ian Lynagh <igloo@earth.li>**20090521133614] 
[Clean gmp.h
Ian Lynagh <igloo@earth.li>**20090521133606] 
[Need to pass gcc -m64 on amd64 OSX
Ian Lynagh <igloo@earth.li>*-20090520170508] 
[Set C compiler and linker flags correctly for OS X 64
Ian Lynagh <igloo@earth.li>**20090521124459] 
[Fix #3201: "ar: Bad file number" build error with MSYS and SplitObjs=YES
Simon Marlow <marlowsd@gmail.com>**20090521103131
 Ignore-this: b86763ca5f36447f633a9b9a5f58ecf8
] 
[fix warning (and validate)
Simon Marlow <marlowsd@gmail.com>**20090521081932
 Ignore-this: 4d9168fb4caca4ab84e3e06a4a94602
] 
[don't clean GMP before validating (it rarely changes, and is slow to build)
Simon Marlow <marlowsd@gmail.com>**20090521074840
 Ignore-this: 752904e56363c197328079dbde9363f1
] 
[remove a todo item (bug #2966 is fixed)
Simon Marlow <marlowsd@gmail.com>**20090520130504
 Ignore-this: 8c3c6cd3791aba3336e3e8052ceddab9
] 
[When linking a shared library with --make, always do the link step
Duncan Coutts <duncan@well-typed.com>**20090519121149
 Without -shared, the default target is a binary and in that case
 it makes sense for --make to not try and link a binary when there
 is no Main module. But for a shared library the user already has
 to specify -shared and there's no reason a shared lib should
 contain any Main module or main function.
] 
[Pass --enable-shared and --with-hscolour to ghc-cabal configure
Duncan Coutts <duncan@well-typed.com>**20090519120953
 It tried to do this already, but the make variable name was wrong.
] 
[Use shared lib mode -dynload deploy to build the rts and core shared libs
Duncan Coutts <duncan@well-typed.com>**20090519120801
 This is now the same as the old default. Currently we cannot embed
 rpaths because they would point to the build tree. We should embed
 rpaths relative to the $ORIGIN in future.
] 
[Make -dynload sysdep mean to embed rpaths in shared libs as well as binaries
Duncan Coutts <duncan@well-typed.com>**20090519120533
 Previously it only did it for binaries. This was presumably on the
 theory that the binary could specify the rpath for all the libs.
 However when it is the shared lib that is the final product (ie to
 link into a bigger project) then we need the rpaths for the shared
 lib to be self-contianed.
] 
[Switch the default -dynload mode to SystemDependent
Duncan Coutts <duncan@well-typed.com>**20090517003630
 The previous default was Deployable though it was being
 overridden to Wrapper in the ghc shell script wrapper.
] 
[Set the soname when creating a shared lib
Duncan Coutts <duncan@well-typed.com>**20090515203730
 It's still possible to override it, just use -optl-Wl,-soname, eg:
 ghc -shared -dynamic foo.o -o libfoo.so -optl-Wl,-soname,libbar.so
] 
[Keep C main separate from rts lib and link it in for standalone progs
Duncan Coutts <duncan@well-typed.com>**20090515160814
 Previously the object code for the C main function lived in the rts
 lib, however this is a problem when the rts is built as a shared lib.
 With Windows DLLs it always causes problems while on ELF systems it's a
 problem when the user decides to use their own C main function rather
 than a Haskell Main.main. So instead we now put main in it's own tiny
 little static lib libHSrtsmain.a which we install next to the rts libs.
 Whenever ghc links a program (without -no-hs-main) then it also links
 in -lHSrtsmain. For consistency we always do it this way now rather
 than trying to do it differently for static vs shared libraries.
] 
[Remove old Windows-only implementation of keeping main outside the rts
Duncan Coutts <duncan@well-typed.com>**20090514183550
 We now do it for all ways and for all platforms. This was a Windows-only
 version that only kept a separate Main.dyn_o for the dynamic linking case.
 It had to do that because Windows DLLs are stricter about unresolved symbols
 where as for ELF platforms we only run into the problem when we're not using
 a Haskell main function.
] 
[Fix silly make macro mistake in a rule used in the --enable-shared case
Duncan Coutts <duncan@well-typed.com>**20090514184216] 
[Windows: load msvcrt and kernel32 manually
Simon Marlow <marlowsd@gmail.com>**20090520124310
 Ignore-this: ae3fc7bf3e07bd0c4b30f2f6e6e04a53
] 
[Need to pass gcc -m64 on amd64 OSX
Ian Lynagh <igloo@earth.li>**20090520224020] 
[OS X / amd64 fixes
Ian Lynagh <igloo@earth.li>**20090520223610] 
[Fix the unregisterised build
Ian Lynagh <igloo@earth.li>**20090520221046] 
[Build fix for amd64/OSX
Ian Lynagh <igloo@earth.li>**20090520211705] 
[Fix building with the HEAD
Ian Lynagh <igloo@earth.li>**20090520202532] 
[make [123] omits phases 1,2, and 3
Simon Marlow <marlowsd@gmail.com>**20090519083419
 Ignore-this: 899fc1fb6707fde243e3a1e2221f768a
] 
[allow phases to be omitted by setting OMIT_PHASE_[123]=YES
Simon Marlow <marlowsd@gmail.com>**20090519083350
 Ignore-this: 4ac4a0ab2547dcccce5e2fdfe83525aa
] 
[fix a dependency: Makefile -> includes/Makefile
Simon Marlow <marlowsd@gmail.com>**20090519083317
 Ignore-this: 3447c85226202ae0130326ab011d3473
] 
[Make -Odph imply -fsimplifier-phases=3
Roman Leshchinskiy <rl@cse.unsw.edu.au>**20090519055807
 Ignore-this: 25d9f2ac3f89ebac487254313fcb1b3e
] 
[Add missing word, spotted by Tom Lokhorst
Max Bolingbroke <batterseapower@hotmail.com>**20090518153314] 
[fix typo: TH.ModName -> TH.PkgName
Simon Marlow <marlowsd@gmail.com>**20090518120457
 Ignore-this: c52d36b33b0446a925156c5c4d47d373
] 
[Fix #3236: emit a helpful error message when the RTS has not been initialised
Simon Marlow <marlowsd@gmail.com>**20090518104108
 Ignore-this: ff4b5e9c226832feb08b1e69e0bdbfcb
] 
[Fix #3207: add has_side_effects = True for lots of primops
Simon Marlow <marlowsd@gmail.com>**20090515143608
 Ignore-this: 6dd688582c3c5f506eac75f409185cf2
 and document primOpHasSideEffects
] 
[Need to pass gcc -m64 on amd64 OSX
Ian Lynagh <igloo@earth.li>**20090520170508] 
[Use machdepCCOpts when running "as"
Ian Lynagh <igloo@earth.li>**20090520165811] 
[Use SRC_HC_OPTS when making ghc-cabal and ghc-pkg
Ian Lynagh <igloo@earth.li>**20090520130009] 
[Fix building ghc-pkg when bootstrapping
Ian Lynagh <igloo@earth.li>**20090520122241] 
[Simplify ghc-pkg's ghc.mk slightly
Ian Lynagh <igloo@earth.li>**20090520121940] 
[Set CLEANING=YES for the clean_% targets
Ian Lynagh <igloo@earth.li>**20090520114312] 
[Use SRC_CC_OPTS when making HSffi.o
Ian Lynagh <igloo@earth.li>**20090519195742] 
[Bootstrapping fixes
Ian Lynagh <igloo@earth.li>**20090517130558] 
[Bootstrapping fixes
Ian Lynagh <igloo@earth.li>**20090517001146] 
[Bootstrapping fixes
Ian Lynagh <igloo@earth.li>**20090516183020] 
[Remove a done TODO item
Ian Lynagh <igloo@earth.li>**20090516175836] 
[Add libraries/dph/LICENSE to bindists
Ian Lynagh <igloo@earth.li>**20090516130016] 
[Tweak bindist creation
Ian Lynagh <igloo@earth.li>**20090516125527
 libraries built by stage2 need all their bits in the bindist too.
 We were testing (stage == 1) rather than (stage /= 0).
] 
[Move the fixed paths out of config.mk, so cleaning works without configuring
Ian Lynagh <igloo@earth.li>**20090516121248] 
[Remove an incorrect comment
Ian Lynagh <igloo@earth.li>**20090516120255] 
[Hide more make rules when cleaning
Ian Lynagh <igloo@earth.li>**20090516114511] 
[Remove some $(TOP)s that cause problems on Windows (as they contain ':')
Ian Lynagh <igloo@earth.li>**20090516001118] 
[Disable suffix rules when cleaning
Ian Lynagh <igloo@earth.li>**20090515231947] 
[Don't require the library ghc.mk files in order to clean
Ian Lynagh <igloo@earth.li>**20090515231516] 
[Add a maintainer-clean rule
Ian Lynagh <igloo@earth.li>**20090515225659] 
[Make dph required
Ian Lynagh <igloo@earth.li>**20090515205122] 
[Remove --extra flag from darcs-all
Ian Lynagh <igloo@earth.li>**20090515203646] 
[Remove nofib-analyse
Ian Lynagh <igloo@earth.li>**20090515200241
 It's now in the nofib repo.
] 
[Further fixes to the stage1 version hack; fix validate.
Simon Marlow <marlowsd@gmail.com>**20090515111109
 Ignore-this: 8c75bbe34fdf9ab63b3937d1d16db625
 I'm less convinced this is a good idea now.  But it does avoid
 rebuilding most of stage1 when you pull and reconfigure.  Better
 solutions welcome.
] 
[remove warning settings; we already have warnings turned on everywhere
Simon Marlow <marlowsd@gmail.com>**20090515094046
 Ignore-this: 25fda62eb47c7a324b30cd0cd942d1ef
] 
[disable all docs in the "quick" and "devel" builds
Simon Marlow <marlowsd@gmail.com>**20090515093500
 Ignore-this: 1ef50b4624bd196584feb3d4da64a6
] 
[remove XmlDocWays relic
Simon Marlow <marlowsd@gmail.com>**20090515094452
 Ignore-this: 98fe2765fb54d3fcd890fcb3e193bc3e
] 
[cleanup: remove reference to $1_$2_CONFIGURE_FLAGS, which is never used
Simon Marlow <marlowsd@gmail.com>**20090515092858
 Ignore-this: a563c6706dc5d072f4dd5341e37bbb16
 we also have $1_$2_CONFIGURE_OPTS, which is used.
] 
[fix cut-and-pasto in mkWeakForeignEnv#, causing random segfaults
Simon Marlow <marlowsd@gmail.com>**20090515092356
 Ignore-this: cac2a0ae0a9535992466a85d1fb877b7
] 
[Fix maintainer-clean for library/dph
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090515024812
 Ignore-this: 189a52c2b3a6cd90fa23e74cc455244
] 
[Move hasktags out of the GHC repo
Ian Lynagh <igloo@earth.li>**20090515135755
 Now configure looks for it as an installed program instead.
] 
[use StgWord for the lock (fixes valgrind complaint on 64-bit machines)
Simon Marlow <marlowsd@gmail.com>**20090514145524
 Ignore-this: 23100384044c7ecf26e7e552582bcccd
] 
[don't rebuild the whole of stage 1 just because the date has changed
Simon Marlow <marlowsd@gmail.com>**20090514093636
 Ignore-this: f4b7eceae68033723e6eb79f3972636d
] 
[Remove left-over bits of extralib support
Ian Lynagh <igloo@earth.li>**20090514125804] 
[Clean the right directory in bindisttest
Ian Lynagh <igloo@earth.li>**20090514125044] 
[validate now uses maintainer-clean, not distclean
Simon Marlow <marlowsd@gmail.com>**20090514105717
 Ignore-this: fc63835c465928e7b996d548661c26bf
] 
[main repeated 'make maintainer-clean' not fail
Simon Marlow <marlowsd@gmail.com>**20090514105704
 Ignore-this: 81fa6dbd35ccc9d8081ad5b3ebda3113
] 
[make repeated 'make distclean' not fail
Simon Marlow <marlowsd@gmail.com>**20090514105645
 Ignore-this: f637c255cf741f256114a98d63f47768
] 
[dummy-ghc should depend on config.mk, to pick up the latest version number
Simon Marlow <marlowsd@gmail.com>**20090513144444
 Ignore-this: 790a4e0c40f435c395eabaab50ccae9b
 This fixes build problems of the form
   ghc-cabal: Version mismatch between ghc and ghc-pkg
] 
[rejig ghc version test; fail if GHC version can't be determined
Simon Marlow <marlowsd@gmail.com>**20090513103905
 Ignore-this: a905701fd9cb8bd09a9b423998e8d98d
] 
[Improve error reporting for kind errors (fix Trac #1633)
simonpj@microsoft.com**20090513151130
 Ignore-this: 80c4b0d98ac25bececf0896d27f954b8
 
 A long-standing improvement to the error message for kinds. Now instead of
     Expected kind `* -> *', but `Int' has kind `*'
 we get
     The first argument of `T' should have kind `* -> *',
     but `Int' has kind `*'
 
 Ha!
 
] 
[Fix Trac #3219: type of a record update
simonpj@microsoft.com**20090513150922
 Ignore-this: 95af0b6c81a888839528327905f849fa
 
 Record updates are amazingly hard to typecheck right.  This is one place
 where GHC's policy of typechecking the original source is much harder than
 desugaring and typechecking that!
 
 Anyway, the bug here is that to compute the 'fixed' type variables I was
 only looking at one constructor rather than all the relevant_cons
 
 Test is typecheck/should_compile/T3219, which GHC 6.10 barfs on (with Lint).
 
] 
[Add comments
simonpj@microsoft.com**20090513145944
 Ignore-this: 8f799933bf7b2bc72ba67e999afd6fe0
] 
[Hide warnings from alex/happy sources
Ian Lynagh <igloo@earth.li>**20090514005450] 
[Fix some warnings in Lexer
Ian Lynagh <igloo@earth.li>**20090513234042] 
[Fix building dph in the new build system
Ian Lynagh <igloo@earth.li>**20090513160531] 
[Link the rts shared libs against gmp and the other C libs
Duncan Coutts <duncan@well-typed.com>**20090501235824
 When using shared libs we should link each lib against its deps. This allows
 the dynamic linker to chase dependencies and means we do not have to specify
 all indirect dependencies (as we must do for static libs).
] 
[Make ghc -dynamic imply -fPIC for C code
Duncan Coutts <duncan@well-typed.com>**20090501121445
 As is already the case for ghc -fPIC. This is needed because ghc -dynamic
 means to generate code that is capable of being linked to Haskell shared
 libs and for C code the equivalent is -fPIC. Normally C code does not need
 -fPIC merely to link to shared libs however Haskell shared libs do not
 follow common conventions. In particular the static data cannot be
 referenced statically because it cannot be copied by the static linker.
 The linker cannot copy them because we do not specify a .size for the
 _closure entries (in the .data section) though in principle we could.
] 
[validate does "exit 1" if it fails
Simon Marlow <marlowsd@gmail.com>**20090513102044
 Ignore-this: f032189c358c133f2b00f062de28890a
] 
[fix warning
Simon Marlow <marlowsd@gmail.com>**20090513101649
 Ignore-this: d93e813fd3010f157768b04ebabe8880
] 
[remove old unused fop/dvips/xmltex stuff
Simon Marlow <marlowsd@gmail.com>**20090513100317
 Ignore-this: a3ff10c53c7fb630d019e47611ff07a6
] 
[build Haddock docs
Simon Marlow <marlowsd@gmail.com>**20090513100142
 Ignore-this: 867538ef3a566197f24b73c70407a6f1
] 
[enable LinkDynLib in compilier phase
y.zhuang5@lse.ac.uk**20090422201937
 Ignore-this: 615f399aae08a19ea5047e7c0c4a67d4
] 
[expand hack to include PS docs too
Simon Marlow <marlowsd@gmail.com>**20090513075903
 Ignore-this: f9f7914eeaef39bf357cd47984692417
] 
[stub Makefile
Simon Marlow <marlowsd@gmail.com>**20090511145122
 Ignore-this: 837a294680f957880d5ce24bec293bf1
] 
[GhcBootLibs is no more
Simon Marlow <marlowsd@gmail.com>**20090511145006
 Ignore-this: 1de74fa020bdb341c852c39bb427b98f
] 
[updates to the section describing the  +RTS -s/-S output (#3211)
Simon Marlow <marlowsd@gmail.com>**20090511144935
 Ignore-this: 1a472f099d4db1aa04c86a250a64036
] 
[multi-slurp protection
Simon Marlow <marlowsd@gmail.com>**20090508092200
 Ignore-this: 147a78b3d43e55804df50807facfe1ed
] 
[Improve error messages for type functions
simonpj@microsoft.com**20090512171229
 Ignore-this: 69207771396a7940b1bb1413622b0b5d
 
 Following a suggestion of Claus Reinke, this patch improves the error
 messages involving type functions.  Here's the relevant note from TcTyFuns.
 
 Note [Non-injective type functions]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 It's very confusing to get a message like
      Couldn't match expected type `Depend s'
             against inferred type `Depend s1'
 so pp_open_tc adds:
        NB: `Depend' is a (non-injective) type function
 
 Currently we add this independently for each argument, so we also get
      Couldn't match expected type `a'
             against inferred type `Dual (Dual a)'
        NB: `Dual' is a (non-injective) type function
 which is arguably redundant.  But on the other hand, it's probably
 a good idea for the programmer to know the error involves type functions
 so I've left it in for now.  The obvious alternative is to only add
 this NB in the case of matching (T ...) ~ (T ...). 
 
] 
[stub makefile
Simon Marlow <marlowsd@gmail.com>**20090511133615
 Ignore-this: 1d5890844e9329eb832def2caab142f7
] 
[Hack to make the user's guide build in a linked build tree
Simon Marlow <marlowsd@gmail.com>**20090511133523
 Ignore-this: ff861fdc8a2f30ad970f1afe2121d4b6
 See comment for details
] 
[make it so that 'make html', 'make pdf', and 'make ps' work for docs
Simon Marlow <marlowsd@gmail.com>**20090511120256
 Ignore-this: 31314dbdf6d1b81142a0618ff80d79af
] 
[correct the +RTS -? docs for -A (default is 512k not 256k)
Simon Marlow <marlowsd@gmail.com>**20090508083811
 Ignore-this: 3325973d3236d4363da007ae5d052d39
] 
[Use a more compact +RTS -s output for Tasks
Simon Marlow <marlowsd@gmail.com>**20090508083738
 Ignore-this: 120572f8f207d709268389f83d6e3930
 
                         MUT time (elapsed)       GC time  (elapsed)
   Task  0 (worker) :    0.00s    (  0.00s)       0.00s    (  0.00s)
   Task  1 (worker) :    0.00s    (  0.01s)       0.00s    (  0.00s)
   Task  2 (worker) :    0.00s    (  0.03s)       0.00s    (  0.00s)
   Task  3 (bound)  :    0.00s    (  0.00s)       0.02s    (  0.04s)
] 
[disable a warning
Simon Marlow <marlowsd@gmail.com>**20090505092015
 Ignore-this: 88be67365fd00a0e82374bd543220224
] 
[docbook PDF item is done
Simon Marlow <marlowsd@gmail.com>**20090505092009
 Ignore-this: be0fea575eb930a040b7b15bd11f0eb1
] 
[add a .c --> .s rule
Simon Marlow <marlowsd@gmail.com>**20090501095627
 Ignore-this: d21dc88910d189cce35ce2d26028b547
] 
[Remove libraries/ifBuildable.hs; it's no longer used
Ian Lynagh <igloo@earth.li>**20090509200708] 
[Fix configure
Ian Lynagh <igloo@earth.li>**20090509184634] 
[Build system tweak
Ian Lynagh <igloo@earth.li>**20090509142936] 
[Add a Makefile in libraries/
Ian Lynagh <igloo@earth.li>**20090508232920] 
[Tweak ./boot
Ian Lynagh <igloo@earth.li>**20090508230236] 
[Partially fix "make framework-pkg"
Ian Lynagh <igloo@earth.li>**20090508224857
 We still need to sort out the "install-docs" story to get this working
 properly.
] 
[Handle deciding what docs to build better
Ian Lynagh <igloo@earth.li>**20090508000603
 Now we have variables for whether or not to build the docbook docs as
 HTML, as PS, and as PDF. The configure script output now matches what
 the build system will do (except it cannot take account of any
 mk/build.mk settings, of course).
] 
[Remove oldconfig.mk.in
Ian Lynagh <igloo@earth.li>**20090507150641] 
[Rename pwd to ghc-pwd
Ian Lynagh <igloo@earth.li>**20090507135034] 
[Remove pwd's Makefile from the old build system
Ian Lynagh <igloo@earth.li>**20090507134356] 
[Clean utils/pwd
Ian Lynagh <igloo@earth.li>**20090507134259] 
[Use more portable shell in ./boot; fixes booting on Solaris
Ian Lynagh <igloo@earth.li>**20090506010445] 
[Simplify utils/pwd
Ian Lynagh <igloo@earth.li>**20090505223432
 We only need the forwardslash mode now, so always use that mode and
 don't accept any arguments.
] 
[More rules for bootstrapping
Ian Lynagh <igloo@earth.li>**20090504150209] 
[Bootstrapping fix
Ian Lynagh <igloo@earth.li>**20090504142605] 
[Bootstrapping fixes
Ian Lynagh <igloo@earth.li>**20090504142511] 
[Test "ghc-pkg check" passes in bindisttest
Ian Lynagh <igloo@earth.li>**20090504105324
 Also fixes it so that it really does pass (we weren't substituting the
 GMP variables in the RTS package config).
] 
[Put install-sh into bindists
Ian Lynagh <igloo@earth.li>**20090504104026] 
[Test bindists in a deeper subdirectory
Ian Lynagh <igloo@earth.li>**20090504103504
 configure looks for install-sh in . .. ../.. and we don't want it to
 find the build system's install-sh.
] 
[Use "-x c" when compiling hc files
Ian Lynagh <igloo@earth.li>**20090503205344] 
[Makefile rules tweak for BootingFromHc
Ian Lynagh <igloo@earth.li>**20090503203733] 
[More bootstrapping rules
Ian Lynagh <igloo@earth.li>**20090503201812] 
[Add a .hc building rules for bootstrapping
Ian Lynagh <igloo@earth.li>**20090503190508] 
[Tweak rts ghc.mk for bootstrapping
Ian Lynagh <igloo@earth.li>**20090503111009] 
[Add a build system TODO
Ian Lynagh <igloo@earth.li>**20090503224627] 
[Add dph to build system; patch from Roman Leshchinskiy
Ian Lynagh <igloo@earth.li>**20090503104005] 
[add publish-binary-dist; tidy up
Simon Marlow <marlowsd@gmail.com>**20090501112857
 Ignore-this: 7e0032d7ac300f5dd18626488a035c05
] 
[Fix make for libffi again, properly this time
Duncan Coutts <duncan@well-typed.com>**20090430225546
 No idea how the last patch managed to pass validate.
] 
[Fix parallel make for libffi.
Duncan Coutts <duncan@well-typed.com>**20090430135637
 I didn't realise make can invoke the same action multiple
 times in parallel if the rule has multiple targets. So go
 back to using a build stamp file.
] 
[Fix linking shared libs with parallel make
Duncan Coutts <duncan@well-typed.com>**20090430123753
 Unlike with static libs, when linking shared libs the dependencies
 have to already exist. Add a dependency $1_$2_$3_LIBS : $1_$2_$3_DEPS_LIBS
] 
[Fix building without GHCi
Ian Lynagh <igloo@earth.li>**20090503004437] 
[Makefile tweak
Ian Lynagh <igloo@earth.li>**20090502225601] 
[Fix building Haskeline on Windows
Ian Lynagh <igloo@earth.li>**20090430161613] 
[FIX build: add dependencies on ghc_boot_platform.h
Simon Marlow <marlowsd@gmail.com>**20090430100245
 Ignore-this: b9bd4f40f4b6789eee500626b9ef6e2c
] 
[Prevent haddock docs being built when HADDOCK_DOCS=NO
Duncan Coutts <duncan@well-typed.com>**20090429160230] 
[Clean up building of libffi for dynamic lib way
Duncan Coutts <duncan@well-typed.com>**20090429153002
 And depend on it at the top level when we're using dynamic libs.
] 
[Build library packages as shared libs
Duncan Coutts <duncan@well-typed.com>**20090429151553
 when we configure ghc with --enable-shared
] 
[Build the rts as a shared lib correctly
Duncan Coutts <duncan@well-typed.com>**20090429143131
 That is, build it as a .so/.dll rather than as libHSrts_dyn.a
] 
[Don't actually build ghc itself with -dynamic
Duncan Coutts <duncan@well-typed.com>**20090429142940
 For now, with --enable-shared we'll build the libs shared,
 but ghc itself will still be statically linked.
 In any case, we would want to be able to build it both
 ways so it's easy to test both.
] 
[Add a new $way_libsuf variable for library suffix+extension
Duncan Coutts <duncan@well-typed.com>**20090428123529
 This allows the library file type to depend on the way. This is needed
 to use .so/.dll libs for the "dyn" way rather than always using .a libs.
 For example: thr_debug_dyn_libsuf="_thr_debug-ghc6.11.20090426.so"
] 
[extend the rules/c-objs macro to take the way as a parameter
Duncan Coutts <duncan@well-typed.com>**20090428123452
 Previously we only built library package "cbits" the vanilla way, afterall
 C code does not need to be built differently for profiling builds. However
 for dynamic libs the C code needs to be built with -fPIC, so we do need
 to be able to build package .c (and .s?) files multiple ways.
] 
[Do not link ghc stage1 using -threaded, only for stage2 or 3
Duncan Coutts <duncan@well-typed.com>**20090428104924
 We link stage1 using the bootstrapping compiler and there's
 no guarantee that it has working support for threaded
] 
[Fix mkdependC: Make it tell cpp to use our temporary filename
Ian Lynagh <igloo@earth.li>**20090430130638] 
[Tweak ghc-cabal
Ian Lynagh <igloo@earth.li>**20090429183728] 
[Add special support for haskeline
Ian Lynagh <igloo@earth.li>**20090429181909
 The library uses stuff in Setup.hs to determine whether or not it needs
 to use -liconv. This patch replicates that logic in ghc-cabal. This
 isn't pretty, and we should find a better way to do it, but it works
 for now.
] 
[In mkdependC.prl, create temp files properly
Ian Lynagh <igloo@earth.li>**20090429151215
 Avoids a race condition, where one run deletes/overwrites the temp file
 of another.
] 
[move nofib settings here from ghc's config.mk
Simon Marlow <marlowsd@gmail.com>**20090428125551
 Ignore-this: a2eb9d0094fe10446b74987af44a6005
] 
[add missing eventlog subdir
Simon Marlow <marlowsd@gmail.com>**20090428125528
 Ignore-this: 127bc2a6bc9fa29871a19ad99ddb346e
] 
[move runstdtest into nofib
Simon Marlow <marlowsd@gmail.com>**20090428124505
 Ignore-this: 98eae5d994693ed8235e8693f3615899
] 
[Use haskeline, rather than editline, for line editing in ghci
Ian Lynagh <igloo@earth.li>**20090429005838] 
[Fix error handling
Ian Lynagh <igloo@earth.li>**20090428232848
 After the fix to #2500, we could get "Failing due to -Werror." but no
 warnings printed. Now we don't fail in that case.
] 
[FIX #2500: Don't log warnings in getHeader
Simon Marlow <marlowsd@gmail.com>**20090421100039
 Ignore-this: 24a8e8c2dca64dcd592d53fd7468eed5
] 
[improve the finalizer callback error message
Simon Marlow <marlowsd@gmail.com>**20090428085345
 Ignore-this: 3255e17c98b3c9cf591b71d6023592b8
] 
[Add a header to all build system files:
Simon Marlow <marlowsd@gmail.com>**20090428085233
 Ignore-this: 49aa394badd4f17dc17aa3a26085ddba
 
 # -----------------------------------------------------------------------------
 #
 # (c) 2009 The University of Glasgow
 #
 # This file is part of the GHC build system.
 #
 # To understand how the build system works and how to modify it, see
 #      http://hackage.haskell.org/trac/ghc/wiki/Building/Architecture
 #      http://hackage.haskell.org/trac/ghc/wiki/Building/Modifying
 #
 # -----------------------------------------------------------------------------
] 
[more cleaning
Simon Marlow <marlowsd@gmail.com>**20090428084919
 Ignore-this: e41e0dcbef3d410ca5d6a2ff8e433cc8
] 
[todo updates
Simon Marlow <marlowsd@gmail.com>**20090427152529
 Ignore-this: b476fdb991b7b229d4aa837aa6d45216
] 
[remove commentary that is now in the wiki
Simon Marlow <marlowsd@gmail.com>**20090427144743
 Ignore-this: e9f6bec77aa99a3c1b49ada0bf4ca9ad
] 
[remove ticket todos
Simon Marlow <marlowsd@gmail.com>**20090427144406
 Ignore-this: 7de6ea0d0ecfc1ca51d75090074dcdd9
] 
[require gcc 3.0+ (see #2770)
Simon Marlow <marlowsd@gmail.com>**20090427134322
 Ignore-this: 4844e99c80bdd0f9a6bdd34bae46748b
] 
[update build order comment
Simon Marlow <marlowsd@gmail.com>**20090427124711
 Ignore-this: 96be57ee425cb4d5a916960273aefe87
] 
[Equality constraint solver is now externally pure
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090427140316
 Ignore-this: bd7c31a7d9e62437e4d83f70b48220af
 - This patch changes the equality constraint solver such that it does not
   instantiate any type variables that occur in the constraints that are to be
   solved (or in the environment).  Instead, it returns a bag of type bindings.
 - If these type bindings (together with the other results of the solver) are
   discarded, solver invocation has no effect (outside the solver) and can be
   repeated (that's imported for TcSimplifyRestricted).
 - For the type bindings to take effect, the caller of the solver needs to 
   execute them. 
 - The solver will still instantiate type variables thet were created during 
   solving (e.g., skolem flexibles used during type flattening).
 
   See also http://hackage.haskell.org/trac/ghc/wiki/TypeFunctionsSolving
] 
[Improve the error message when we find a module in 2 places; trac #3183
Ian Lynagh <igloo@earth.li>**20090426160204] 
[Remove a comment (a bug to close, that has now been closed)
Ian Lynagh <igloo@earth.li>**20090426151942] 
[GHC new build system megapatch
Ian Lynagh <igloo@earth.li>**20090426114215] 
[Fix SPARC build, missing #include
Ben.Lippmeier@anu.edu.au**20090425083345] 
[Fix a lint failure when we have a  ! (# ... #)  pattern in a where clause
Ian Lynagh <igloo@earth.li>**20090424173313
 This showed up when converting ds057 to follow the new bang pattern rules,
 in #2806.
] 
[Do the second part of #2806: Disallow unlifted types in ~ patterns
Ian Lynagh <igloo@earth.li>**20090424150519] 
[Tiny refactor
Ian Lynagh <igloo@earth.li>**20090424140227] 
[Require a bang pattern when unlifted types are where/let bound; #3182
Ian Lynagh <igloo@earth.li>**20090424124754
 For now we only get a warning, rather than an error, because the alex
 and happy templates don't follow the new rules yet.
] 
[Don't short out top-level indirections if there's a INLINE/NOINLINE pragma
simonpj@microsoft.com**20090424123238
 Ignore-this: 422a4256a63c93a0bf806cbfa564ec69
 
 The top-level indirection-shorting, done in SimplCore.shortOutIndirections,
 was accidentally nuking a NOINLINE pragma.  This patch adopts a slightly
 more conservative approach to indirection-shorting, only doing so if 
 we do not thereby overwrite or lose some user-supplied pragmas.
 
] 
[Fix #3182: 64 bit FP value returned by C calls was getting trashed
Ben.Lippmeier@anu.edu.au**20090424065053
 Ignore-this: 529bfd2bfb663a70e1345a0089737496
    movss instruction was being used to move the result into the 
    destination register instead of movsd
] 
[add missing files (part of #3171 fix)
Simon Marlow <marlowsd@gmail.com>**20090424091610
 Ignore-this: 3d11fe878c873529906f67e930c46c2c
] 
[Tiny optimisation to mkInlineMe
simonpj@microsoft.com**20090424074733
 Ignore-this: be1e8ed22a82f1dc348b1e047a986d8b
] 
[Add EVENT_CREATE_SPARK_THREAD to replace EVENT_SPARK_TO_THREAD
Simon Marlow <marlowsd@gmail.com>**20090423141940
 Ignore-this: 173128c92c20e6a85d6611355fb5273a
 Also some tidyups and renaming
] 
[add getOrSetSignalHandlerStore, much like getOrSetTypeableStore
Simon Marlow <marlowsd@gmail.com>**20090423113002
 Ignore-this: d9dcb835444cae366aa8f6bcf68fd191
 Part of the fix for #3171
] 
[don't overwrite io_manager_pipe if it is already set
Simon Marlow <marlowsd@gmail.com>**20090423112939
 Ignore-this: 8e7d94a051b4b3daec89ea3103678550
 Part of the fix for #3171
] 
[Simplify the placeholder binding for naughty record selectors
simonpj@microsoft.com**20090423094401
 Ignore-this: 50dca18eeaa60e24319ed75dabf55bab
] 
[Fix Trac #3176: intercept naughty record selectors
simonpj@microsoft.com**20090423094237
 Ignore-this: 1aab5295a20191d8a56364f1fbf2e765
 
 When making record selectors into ordinary functions (rather than
 magial implicit Ids) I forgot that they could therefore show up in 
 the *local* TcEnv, not the global one.  This fixes that problem,
 and thereby Trac #3176.
 
] 
[Better pretty-printing for IdDetails
simonpj@microsoft.com**20090423093945
 Ignore-this: 34721cec14f1ad33838f12bfc7851a48
] 
[FIX #3166: include the fixity of classes and type synonyms in their fingerprints
Simon Marlow <marlowsd@gmail.com>**20090421135624
 Ignore-this: 5390a8fb76bf1f3133f08277a978cb2
] 
[FIX #2682: banish silly cases of the "module Foo is not loaded" error
Simon Marlow <marlowsd@gmail.com>**20090421131038
 Ignore-this: 15298691a63e13c63a68673202b1fc18
 
 In GHCi if you say 'import Foo' meaning to load a package module Foo,
 and Foo.hs is found on the search path, then GHCi replies "module Foo
 is not loaded", because it knows Foo refers to the source file rather
 than the package module, and you haven't loaded that module with
 :load.
 
 This is consistent with the usual module-finding semantics.  However,
 it isn't particularly useful.  And it leads to silly problems like not
 being able to start GHCi when you happen to be sitting in
 libraries/base, because GHCi thinks the Prelude hasn't been loaded.
 
 So now I've made a slight change to the way that 'import M' works: if
 M is loaded, then it refers to the loaded module, otherwise it looks
 for a package module M.  This does what the reporter of #2682 wanted,
 and since it turns an error condition into meaningful behaviour it
 can't break anything.  
 
 The only undesirable consequence is that 'import M' might refer to a
 different M than ':load M'.  Hopefully that won't lead to confusion.
] 
[add a DO NOT EDIT comment
Simon Marlow <marlowsd@gmail.com>**20090421094606
 Ignore-this: d0e81a968fe38918d2830dcf1186f61c
] 
[FIX #3153: we lost an EOF sentinel in the event of a lexical error
Simon Marlow <marlowsd@gmail.com>**20090421094558
 Ignore-this: e30401ca719605a6991e9c8a31821eba
] 
[FIX #2845: Allow breakpoints on expressions with unlifted type
Simon Marlow <marlowsd@gmail.com>**20090420142525
 Ignore-this: 8d1b2624a4635b421032463219af604e
 
 It turns out we can easily support breakpoints on expressions with
 unlifted types, by translating 
 
   case tick# of _ -> e
 
 into
 
   let f = \s . case tick# of _ -> e 
   in  f realWorld#
 
 instead of just a plain let-binding.  This is the same trick that GHC
 uses for abstracting join points of unlifted type.
 
 In #2845, GHC has eta-expanded the tick expression, changing the
 result type from IO a to (# State#, a #), which was the reason the
 tick was suddenly being ignored.  By supporting ticks on unlifted
 expressions we can make it work again, although some confusion might
 arise because _result will no longer be available (it now has
 unboxed-tuple type, so we can't bind it in the environment).  The
 underlying problem here is that GHC does transformations like
 eta-expanding the tick expressions, and there's nothing we can do to
 prevent that.
] 
[remove now-unused atomic_modify_mutvar_mutex
Simon Marlow <marlowsd@gmail.com>**20090403132731
 Ignore-this: d27c29bdd8a4c43b384e278fb192138e
] 
[SPARC NCG: Add a comment explaining why we can't used a pinned reg for gct
Ben.Lippmeier@anu.edu.au**20090420074335
 Can't use windowed regs because the window moves during a function
 call. Can't use the global regs because they're reserved for other purposes.
] 
[SPARC NCG: validate fixes
Ben.Lippmeier@anu.edu.au**20090420032120
 Ignore-this: 4df988a6b3c005de741a300313104408
] 
[SPARC NCG: Base freeRegs on includes/MachRegs.h again
Ben.Lippmeier@anu.edu.au**20090420020700] 
[Really fix Trac #2611 this time
pepe iborra <mnislaih@gmail.com>**20090419142241
 
 My previous patch didn't completely solve the problem.
 I believe I got it right this time.
] 
[Fix Trac #2611
pepe iborra <mnislaih@gmail.com>**20090418214115
 
 Fix a bug in :print affecting data types with unboxed components
 
] 
[Fix #3170: Allow coalescing of the same node during register allocation.
Ben.Lippmeier@anu.edu.au**20090418082253
 Ignore-this: b3a14959d7616fd53c3334a4f0b30f48
   The x86 code generator sometimes generates nop moves like
   movl %vI_a %vI_a, but we'll just ignore them for coalescing
   purposes instead of emitting an error. It shouldn't hurt anything.
] 
[Fix my previous patch about type parsing
David Waern <david.waern@gmail.com>**20090418082927
 
 I forgot to record some additional changes.
] 
[Simplify the type grammar
David Waern <david.waern@gmail.com>**20090417145855
 
 Simon P-J suggested the following simplifications in #3097:
 
 * Allow nested foralls in `ctype` just like in `ctypedoc`.
 * Use `gentype` rather than `type` in the LHS of type declarations.
 * Inline `type` in `ctype`.
 * Rename `gentype` to `type`.
 
 This patch does this. Also, the equivalent thing is done for documented types.
] 
[Removed unused function postEventTypeID.
donnie@darthik.com**20090413011745
 Ignore-this: cbab58da40e0d3b6d124347b9fda8e4
 postEventTypeID was used to post event marker IDs, but instead we just
 call postWord16 directly; thus, this function is unused.
] 
[For consistency, changed access of thread id to be through capability instead of directly from StgRegTable.
donnie@darthik.com**20090413011701
 Ignore-this: dd38adce264aa882be0a4daf7c8c7378
] 
[Added new EventLog event: Spark to Thread.
donnie@darthik.com**20090413011444
 Ignore-this: d38be4d01d76297953d6ed075896cb97
] 
[Changed postEvent last argument from "nat from" to "StgWord64 other".
donnie@darthik.com**20090413011140
 Ignore-this: b7991c781c09d7a631230740cd8b1fe6
 StgWord64 other better represents this argument since it can be used as
 any particular data, thus "other" and not the "from" capability as it was
 previously strictly used.  Also, StgWord64 is normally larger than type
 nat to allow for larger data to be passed through the "other" argument.
] 
[Fixed ThreadID to be defined as StgThreadID, not StgWord64.  Changed CapabilityNum to CapNo.  Added helper functions postCapNo() and postThreadID().
donnie@darthik.com**20090413010705
 Ignore-this: dde2f442f9d5e43f20f52069dee4f8c0
 ThreadID was StgWord64, but should have been StgThreadID, which is
 currently StgWord32.  Changed name from CapabilityNum to CapNo to better
 reflect naming in Capability struct where "no" is the capability number.
 Modified EventLog.c to use the helper functions postCapNo() and
 postThreadID () for CapNo and ThreadID.
] 
[Fixed error in order of EventTypeDescriptions -- seq and par GC come after start and finish GC.
donnie@darthik.com**20090403034322
 Ignore-this: 98c0367103ab7892980d9a17d442584e
 EventTypeDescriptions order must be synchronized with the event type
 definitions in includes/EventLogFormat.h for the definitions to correctly
 index with the matching description.
] 
[Eventlog support for new event type: create spark.
donnie@darthik.com**20090403033025
 Ignore-this: 1da2a5eb13c7c64132234323e2acb514
] 
[Tweak a Show instance
Ian Lynagh <igloo@earth.li>**20090407143057] 
[Fix Trac #3155: better error message when -XRankNTypes is omitted
simonpj@microsoft.com**20090409144004
 Ignore-this: fc9d3035cd461c8a892332facd86c7da
 
 This patch sligtly re-adjusts the way in which the syntax of types 
 is handled:
 
  * In the lexer, '.' and '*' are always accepted in types
    (previously it was conditional).  This things can't mean
    anything else in H98, which is the only reason for doing things
    conditionally in the lexer.
 
  * As a result '.' in types is never treated as an operator.
    Instead, lacking a 'forall' keyword, it turns into a plain parse error.
 
  * Test for -XKindSignatures in the renamer when processing
      a) type variable bindings
      b) types with sigs (ty :: kind-sig)
 
  * Make -XKindSignatures be implied by -XTypeFamilies 
    Previously this was buried in the conditonal lexing of '*'
 
] 
[Use return instead of returnM, and similar tidy-ups
simonpj@microsoft.com**20090409140959
 Ignore-this: 987baeb20a3ff9f07c7a103ca5258c70
] 
[Don't use thread local storage on x86/not-Linux
Ian Lynagh <igloo@earth.li>**20090404003445
 With the
     On x86, use thread-local storage instead of stealing a reg for gct
 patch, on Windows and OS X:
     error: thread-local storage not supported for this target
] 
[Make some showSDoc's use OneLineMode rather than PageMode
Ian Lynagh <igloo@earth.li>**20090331181948] 
[Make the showSDoc definition more explicit
Ian Lynagh <igloo@earth.li>**20090331174103] 
[eliminate warnings
dias@eecs.tufts.edu**20090403203429] 
[Debugging by Sesame Street:
dias@eecs.tufts.edu**20090403201504
 
 One of these things is not like the others:
 
 stdPattern :: [LRep] -> Maybe StgHalfWord
 stdPattern reps
   = case reps of
         []  -> Just ARG_NONE    -- just void args, probably
         [N] -> Just ARG_N
         [P] -> Just ARG_N
         [F] -> Just ARG_F
         [D] -> Just ARG_D
         [L] -> Just ARG_L
 
 Today's debugging session was brought to you by the letter P.
] 
[Buggy optimizations caused function-call return to share the function's entry point
dias@eecs.tufts.edu**20090331144639
 - Block concat and branch-chain elimination were allowing a function call
   to return to the caller's entry point. But that doesn't leave anywhere
   for the infotable on the stack, since the SP on return must be the same
   as the SP on entry to the procedure.
] 
[Better handling of node parameter in calling conventions
dias@eecs.tufts.edu**20090325163815
  - Previously, the node was taken as a parameter, then ignored,
    for static closures. Goofy. Now, the vestigial node parameters
    are gone.
] 
[When calling gc, avoid saving node in static closures
dias@eecs.tufts.edu**20090323204744] 
[Code simplifications due to call/return separation; some improvements to how node argument is managed
dias@eecs.tufts.edu**20090323201140] 
[Code simplification due to separate call/return conventions
dias@eecs.tufts.edu**20090323182214] 
[Calls with and without passing node arguments more clearly separated
dias@eecs.tufts.edu**20090323174700] 
[Another small step: call and return conventions specified separately when making calls
dias@eecs.tufts.edu**20090323172837] 
[Small step toward call-conv improvement: separate out calls and returns
dias@eecs.tufts.edu**20090323170706] 
[On x86, use thread-local storage instead of stealing a reg for gct
Simon Marlow <marlowsd@gmail.com>**20090403121816
 Ignore-this: b132a4c2f56a955adb8537442ca8eb0f
 Benchmarks show that using TLS instead of stealing a register is
 better by a few percent on x86, due to the lack of registers.
 
 This only affects -threaded; without -threaded we're (now) using
 static storage for the GC data.
] 
[in the non-threaded RTS, use a static gc_thread structure
Simon Marlow <marlowsd@gmail.com>**20090403121443
 Ignore-this: 631365db4f9ec7c87f71e0ac851cdfc
] 
[small GC optimisation
Simon Marlow <marlowsd@gmail.com>**20090403083708] 
[add -funroll-loops when compiling the parallel version of Evac.c too
Simon Marlow <marlowsd@gmail.com>**20090402105643
 Ignore-this: c120d5f5ea961e10acad457fd871ba53
] 
[PACKAGE_CPP_OPTS += -DPAPI_INCLUDE_DIR=""
Simon Marlow <marlowsd@gmail.com>**20090402105540
 Ignore-this: 4136707371784c791c435ae4f562a500
 unbreaks ghc-pkg check in an installed GHC
] 
[Adjust inlining heursitics
simonpj@microsoft.com**20090403084634
 Ignore-this: a2d6849726f6705e06941c74137bfe7e
 
 This patch is the result of a long series of nofib-based experiments
 to improve GHC's inlining heuristics.
 
 In the end, I'm not sure how worthwhile it all was: I only got a 
    1% decrease in code size
    1% decrease in allocation
 and I don't trust the runtime statistics enough to quote.
 
 Still, in doing all this I tidied up the code quite a bit, and 
 I understand it much better now, so I'm going to commit it.
 
 The main changes are in CoreUnfold, which has lots of new comments.
 Other changes:
 
   - litSize moves from Literal to CoreUnfold
   - interestingArg moves from SimplUtils to CoreUnfold
   - the default unfolding threshold (in StaticFlags) 
       reduces from 8 to 6 (since the size calculation 
       has changed a bit)
 
 
] 
[Worker/wrapper should make INLINE if it doesn't w/w
simonpj@microsoft.com**20090403084333
 Ignore-this: 5ef3c02c272ad59616fa7dfaa0dc0381
 
 If worker/wrapper decides not to w/w something on the grounds that
 it's too small, it should add an INLINE pragma.  Otherwise, later
 in the day that small thing might now be big, and we'd wish we'd
 done the w/w after all.  This only made a difference in one nofib 
 program (bspt), but it's an easy change.
 
 See Note [Don't w/w inline things (a) and (b)]
 
] 
[Rewrite a good chunk of CoreArity
simonpj@microsoft.com**20090403083655
 Ignore-this: 314d26ad8f2d4437e11148b58e35d731
 
 I found a couple of shortcomings in arity computation, and did
 quite a bit of refactoring as a result.  Regrettably, I have
 forgotten the details, but I do remember that one part was to
 do with the infamous "state hack".  If we're going to use the
 state-hack at all, we'd better do it right.
 
 Anyway I think this is an improvement. The comments are more
 up to date too, and more voluminous.
 
] 
[Comments only; record remarks about removing 'type' nonterminal
simonpj@microsoft.com**20090402165226
 Ignore-this: 82f93bd161ee48c0a745fb58247afec0
] 
[Don't float case expressions in full laziness
simonpj@microsoft.com**20090402165101
 Ignore-this: 356f0fc77301283116a669ed76478c4
 
 See Note [Case MFEs]; don't float case expressions from 
 a strict context.
 
] 
[Fix Trac #3118: missing alternative
simonpj@microsoft.com**20090402152834
 Ignore-this: 9a9866ad88eae871cb98c6795c12349b
 
 This patch fixes a rather obscure bug, whereby it's possible
 for (case C a b of <alts>) to have altenatives that do not inclue
 (C a b)!  See Note [Unreachable code] in CoreUtils.
 
] 
[Use a local interestingDict function instead of importing SimplUtils.interestingArg
simonpj@microsoft.com**20090402152246
 Ignore-this: d01d1a42067c2f907a1f2fb2ddec4ada
 
 I'm changing the details of SimplUtils.interstingArg, and don't want to
 mess  up the way Specialise works, so this patch makes a specilialised
 (ha) function, Specialise.interestingDict, that is used locally.
 
 
] 
[Better panic reporting
simonpj@microsoft.com**20090402151846
 Ignore-this: abbd0ab8e2e8771012c17e0fc66fed41
 
 Make idDetails and idInfo into proper functions, rather than record
 fields, so that we can report more informatively if you use thenm on
 a non-Id.
 
] 
[Fix pragmas in binder-swapping
simonpj@microsoft.com**20090402151616
 Ignore-this: 422672152247c7732c56e850f3317546
 
 In the case binder-swap operation (which is done in OccurAnal),
 we deliberately use shadowing. But the new shadowing binder should
 not inherit any fancy INLINE or NOINLINE pragmas from its parent.
 
] 
[Float constants to top-level even in first full laziness pass
simonpj@microsoft.com**20090402151406
 Ignore-this: c81a6d62b760d50348aaa5de0276d7c6
 
 This patch changes the compilation pipeline flags so that constants
 are floated to the top level even in the first full laziness pass.
 For some reason this was not done before.  Fixing this makes a big
 improvement in 'spectral/rewrite', and has zero effect on any other
 nofib benchmark.
 
] 
[update the intro section
Simon Marlow <marlowsd@gmail.com>**20090401105256
 Ignore-this: 90aba333b501ecdedca5116d7204e47f
] 
[Remove the "Installing GHC" section
Simon Marlow <marlowsd@gmail.com>**20090401103418
 Ignore-this: 94b8c9bcb8a93442ae19f9547f545f74
 
  1. it was out of date in various ways
  2. this is not the place people look for installation instructions
  3. we have installation instructions elsewhere (e.g. the INSTALL
     file in a binary distribution)
  4. the section "layout of installed files" is now on the wiki under
     Building/Installing.
] 
[SPARC: Fix ffi019 split load/store of HsInt64 into two parts to respect alignment constraints
Ben.Lippmeier@anu.edu.au**20090331045145] 
[SPARC NCG: Fix 64 bit addition, carry bit wasn't getting set.
Ben.Lippmeier@anu.edu.au**20090330051732] 
[SPARC NCG: When getting a 64 bit word, promote halves to 64 bit before shifting
Ben.Lippmeier@anu.edu.au**20090330050346] 
[SPARC NCG: HpLim is now always stored on the stack, not in a register
Ben.Lippmeier@anu.edu.au**20090331051900
    This fixes the out of memory errors we were getting on sparc
    after the following patch:
 
      Fri Mar 13 03:45:16 PDT 2009  Simon Marlow <marlowsd@gmail.com>
      * Instead of a separate context-switch flag, set HpLim to zero
      Ignore-this: 6c5bbe1ce2c5ef551efe98f288483b0
      This reduces the latency between a context-switch being triggered and
      the thread returning to the scheduler, which in turn should reduce the
      cost of the GC barrier when there are many cores. 
] 
[Allow Haddock comments in type synonyms
David Waern <david.waern@gmail.com>**20090331212306
 Ignore-this: 11f1bad22d25d8d0017580d020c1aa5d
 
 We now use `ctypedoc` instead of `ctype` for type synonyms. `ctypedoc` was
 previously only used for top-level type signatures. This change means that type
 synonyms now can contain comments, just like top-level type signatures.
   
 Note:
   
 * I've modified `ctypedoc` so it allows implicit parameters and equational
 constraints, just like ctype.
   
 * Since `ctypedoc` allows nested foralls, we now allow that in type synonyms.
   
 * I have inlined some productions into gentypedoc so that there is now a
 non-doc version of every production with a 'doc' suffix. (Stylistic change
 only, which should make the code easier to follow).
   
 * It would have been nice to simplify the grammar by unifying `ctype` and 
 ctypedoc` into one production, allowing comments on types everywhere (and
 rejecting them after parsing, where necessary).  This is however not possible
 since it leads to ambiguity. The reason is the support for comments on record
 fields:
   
 > data R = R { field :: Int -- ^ comment on the field }
   
 If we allow comments on types here, it's not clear if the comment applies
 to 'field' or to 'Int'. So we must use `ctype` to describe the type.
] 
[mkErrorAppDs now takes an SDoc rather than a String
Ian Lynagh <igloo@earth.li>**20090331134058
 This avoids some showSDoc's where the String then gets converted back
 into an SDoc.
] 
[FIX #1779 and qq005: export hs_hpc_module
Simon Marlow <marlowsd@gmail.com>**20090330084414
 Ignore-this: cacd10985619c25505f0e48400187ccc
] 
[go back to using $CPUS + 1 for the number of threads to use
Simon Marlow <marlowsd@gmail.com>**20090330083032
 Ignore-this: 2c1915e2c13b953513a2c16cc86a7073
] 
[use a UniqSet for is MathFun, this list is getting quite large
Simon Marlow <marlowsd@gmail.com>**20090330082957
 Ignore-this: ceaf912ed4ec0d778178e2391715c689
] 
[Fix an nasty black hole, concerning computation of isRecursiveTyCon
simonpj@microsoft.com**20090330084912
 Ignore-this: 3bf163be6629cb933a3be1564ac2b0cc
 
 Fixing #246 (pattern-match order in record patterns) made GHC go into
 a black hole, by changing the order of patterm matching in
 TyCon.isProductTyCon!  It turned out that GHC had been avoiding the
 black hole only by the narrowest of margins up to now!
 
 The black hole concerned the computation of which type constructors
 are recursive, in TcTyDecls.calcRecFlags.  We now refrain from using
 isProductTyCon there, since it triggers the black hole (very
 indirectly).  See the "YUK YUK" comment in the body of calcRecFlags.
 
 As it turns out, the fact that TyCon.isProductTyCon matched on the
 algTcRec field was quite redundant, so I removed that too.  However,
 without the fix to calcRecFlags, this wouldn't fix the black hole
 because of the use of isRecursiveTyCon in BuildTyCl.mkNewTyConRhs.
 
 Anyway, it's fine now.
 
] 
[Add an extra print to -ddump-tc-trace
simonpj@microsoft.com**20090330084835
 Ignore-this: 4197fee2974d94a30af97549a858a44
] 
[Remove dead code (dataConsStupidTheta)
simonpj@microsoft.com**20090330084739
 Ignore-this: 56a6f274aa7194f614a34f664c6e80af
] 
[Fix Trac #246: order of matching in record patterns
simonpj@microsoft.com**20090330083736
 Ignore-this: 2f0a008e0086cfe7ac5100d4253f4fb1
 
 While I was looking at the desugaring of pattern matching (fixing
 Trac #3126) I finally got around to fixing another long-standing bug:
 when matching in a record pattern, GHC should match left-to-right in
 the programmer-specfied order, *not* left-to-right positionally in 
 the original record declaration.
 
 Needless to say, that requires a little more code. 
 See Note [Record patterns] in MatchCon.lhs
 
 
] 
[Fix Trac #3126: matching overloaded literals
simonpj@microsoft.com**20090330083435
 Ignore-this: 560c5e7dba95400bef4a73569ea26b82
 
 Claus Reinke uncovered a long-standing bug in GHC, whereby we were
 combining the pattern-match on overloaded literals, missing the fact
 that an intervening pattern (for a different literal) might also 
 match.  (If someone had a very odd implementation of fromInteger!)
 
 See Note [Grouping overloaded literal patterns] in Match.lhs
 
 If this merges smoothly to 6.10, go for it, but it's very much
 a corner case.
 
 Thank you Claus!
 
] 
[White space cosmetics only
simonpj@microsoft.com**20090330083103
 Ignore-this: c52ebfa8f85e81abcd8694b3a30c6a63
] 
[Improve mkDupableCont; and fix Trac #3116
simonpj@microsoft.com**20090325095205
 
 It turns out that, as a result of a change I made a few months ago to
 the representation of SimplCont, it's easy to solve the optimisation
 challenge posed by Trac #3116.  Hurrah.
 
 Extensive comments in Note [Duplicating StrictArg].
 
] 
[Avoid quadratic complexity in occurrence analysis (fix Trac #1969)
simonpj@microsoft.com**20090323103826
   
   The occurrence analyser could go out to lunch in bad cases, because
   of its clever loop-breaking algorithm. This patch makes it bale out
   in bad cases.  Somewhat ad-hoc: a nicer solution would be welcome.
   
   See Note [Complexity of loop breaking] for the details.
 
] 
[Improve arity propagation in the specialiser
simonpj@microsoft.com**20090323101614
 
 This patch makes the specialiser propagate arities a bit more
 eagerly, which avoids a spurious warning in the simplifier.
 
 See Note [Arity decrease] in Simplify.lhs
 
] 
[check for ThreadRelocated in checkBlackHoles()
Simon Marlow <marlowsd@gmail.com>**20090326140343
 Ignore-this: 5d63f26567030cf0ccfa33da82702f86
] 
[syb no longer needs to be wired in
Ian Lynagh <igloo@earth.li>**20090326130517] 
[Template Haskell: added bang patterns
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090326100208
 Ignore-this: f15890cd7ee7fee664af342796780443
] 
[Template Haskell: support for kind annotations
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090326085520
 Ignore-this: 722c23eac614089d24a8e8373a13de3b
] 
[update list of C math functions
Bertram Felgenhauer <int-e@gmx.de>**20090323183630
 Ignore-this: af5fa15d957d853d27a0c4b465c2419e
 Fix via C compilation of modules that import, say, log1p from math.h (#3117)
 
 The list is based on preprocessing Stg.h with glibc 2.6.1 headers, and
 cross-checked with the ISO C 99 standard (draft).
] 
[Template Haskell: make reify aware of type families
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090325033447
 Ignore-this: 4b9c2d626e7c506a74331bb91d0fcff7
 - Reifying a type family returns a TH family declaration
 - Reifying a data constructor from a data instance attributes that
   constructor to the family (not the representation tycon)
 - Ideally, we should have facilities to reify all type/data instances of a 
   given family (and the same for instances of a class).  I haven't added that
   here as it involves some API design.
] 
[Template Haskell: support for INLINE and SPECIALISE pragmas
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090324232940
 Ignore-this: 1f6c2e0de01842da7c9384d3ccafcb63
] 
[fix an fprintf that should be fputs (quiets gcc)
Simon Marlow <marlowsd@gmail.com>**20090322195441] 
[check return value of write (quiets gcc)
Simon Marlow <marlowsd@gmail.com>**20090322195319] 
[Fix locking in evacuate_large() (FIX openfile008(threaded2))
Simon Marlow <marlowsd@gmail.com>**20090323092953
 Ignore-this: 2c6c2790676c3bcd40f0a0b6030d31dc
] 
[Please the -Wall police by moving a variable declaration; really FIX getNumberOfProcessors() for MacOS X
Austin Seipp <mad.one@gmail.com>**20090320124846
 Ignore-this: fcd0015e0923855df814f55d88770db2
] 
[wibble in setExecutable
Austin Seipp <mad.one@gmail.com>**20090320120043
 Ignore-this: 968aa9856a5494e4e58ca8a20106298f
] 
[FIX getNumberOfProcessors() on MacOS X
Austin Seipp <mad.one@gmail.com>**20090318023127
 Ignore-this: 8df07f3353a8e12be9becf4b855d5fdf
 
 This checks if darwin_HOST_OS is defined and, if so, we call
 sysctlbyname() on the "hw.ncpu" property to get the processor count.
] 
[Work around Solaris's grep not supporting -q
Ian Lynagh <igloo@earth.li>**20090319171501] 
[Some wording wibbles from Thorkil
Ian Lynagh <igloo@earth.li>**20090319165916] 
[Fix bug in setThreadAffinity() (Linux)
Simon Marlow <marlowsd@gmail.com>**20090320100446
 Ignore-this: 6e8b430fe03959f7e7f8c641d5a589f6
] 
[Implement setThreadAffinity for Mac OS X (from 10.5)
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090320071347
 Ignore-this: d5e2104b4a011fc98500527741c5e7a7
] 
[Fix warnings with older versions of gcc (3.4.5)
Simon Marlow <marlowsd@gmail.com>**20090319124932] 
[wibble for getNumberOfProcessors
Simon Marlow <marlowsd@gmail.com>**20090318165936
 Ignore-this: 60a776b8250590f72e45c941b810f14a
] 
[Set thread affinity with +RTS -qa (only on Linux so far)
Simon Marlow <marlowsd@gmail.com>**20090318154719
 Ignore-this: a799d276f29dd24c655e1f423eb6743e
] 
[Template Haskell support for equality constraints
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090319132347
 Ignore-this: 2a0150d9466b0552c5094cdcdc08dbe5
] 
[add missing case in ENTER() (fixes readwrite002(profasm) crash)
Simon Marlow <marlowsd@gmail.com>**20090319102126
 Ignore-this: 5599d4df888e830a8865e57e6745e094
] 
[FIX unregisterised build
Simon Marlow <marlowsd@gmail.com>**20090319100954
 Ignore-this: 97f15b77b030f1f26b0827e6335a8251
] 
[Template Haskell: support for type family declarations
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090319084306
 Ignore-this: b9f5f5af61a5da53dc4326f380fdb72e
] 
[Comment explaining use of seq in DFMonad
dias@eecs.tufts.edu**20090318210138] 
[FIX unregisterised target by #ifdefing targetPlatform stuff
Simon Marlow <marlowsd@gmail.com>**20090318151255
 Ignore-this: 916b3929d0edcd18951591a35e0cc99
 I'm not sure if this is the correct fix.  If targetPlatform is really
 NCG-specific, then maybe we should call it asmTargetPlatform or
 something.
] 
[Removed a trace
dias@eecs.tufts.edu**20090318151343] 
[Calling convention bug and cleanup
dias@eecs.tufts.edu**20090317204238
 - yet another wrong calling convention; this one was a special case for returning one
   value.
] 
[Inconsistent type and arguments in safe foreign calls...
dias@eecs.tufts.edu**20090316214654
 - The function argument was stripped from the argument list but not from the type.
   Now they're both stripped.
] 
[stack overflows and out of memory's
dias@eecs.tufts.edu**20090316213506
 1. Stack overflow fixed by making dataflow monad strict in the state.
 2. Out of memory fixed by "forgetting" lastoutfacts in the dataflow monad
    where we should. We were creating an unnecessarily long list that grew
    exponentially...
] 
[Add the notion of "constructor-like" Ids for rule-matching
simonpj@microsoft.com**20090318105911
 Ignore-this: 9249b00a2292563e68d5d715376b216c
 
 This patch adds an optional CONLIKE modifier to INLINE/NOINLINE pragmas, 
    {-# NOINLINE CONLIKE [1] f #-}
 The effect is to allow applications of 'f' to be expanded in a potential
 rule match.  Example
   {-# RULE "r/f" forall v. r (f v) = f (v+1) #-}
 
 Consider the term
      let x = f v in ..x...x...(r x)...
 Normally the (r x) would not match the rule, because GHC would be scared
 about duplicating the redex (f v). However the CONLIKE modifier says to
 treat 'f' like a constructor in this situation, and "look through" the
 unfolding for x.  So (r x) fires, yielding (f (v+1)).
 
 The main changes are:
   - Syntax
 
   - The inlinePragInfo field of an IdInfo has a RuleMatchInfo
     component, which records whether or not the Id is CONLIKE.
     Of course, this needs to be serialised in interface files too.
 
   - The occurrence analyser (OccAnal) and simplifier (Simplify) treat
     CONLIKE thing like constructors, by ANF-ing them
 
   - New function coreUtils.exprIsExpandable is like exprIsCheap, but
     additionally spots applications of CONLIKE functions
 
   - A CoreUnfolding has a field that caches exprIsExpandable
 
   - The rule matcher consults this field.  See 
     Note [Expanding variables] in Rules.lhs.
 
 On the way I fixed a lurking variable bug in the way variables are
 expanded.  See Note [Do not expand locally-bound variables] in
 Rule.lhs.  I also did a bit of reformatting and refactoring in
 Rules.lhs, so the module has more lines changed than are really
 different.
 
] 
[Fixes to "Retract Hp *before* checking for HpLim==0"
Simon Marlow <marlowsd@gmail.com>**20090318111847
 Ignore-this: 154a41eeb18a775465db29c818d1ec3a
] 
[Add fast event logging
Simon Marlow <marlowsd@gmail.com>**20090317164214
 Ignore-this: c470164a5e66dca06fddc2fe172025de
 
 Generate binary log files from the RTS containing a log of runtime
 events with timestamps.  The log file can be visualised in various
 ways, for investigating runtime behaviour and debugging performance
 problems.  See for example the forthcoming ThreadScope viewer.
 
 New GHC option:
 
   -eventlog   (link-time option) Enables event logging.
 
   +RTS -l     (runtime option) Generates <prog>.eventlog with
               the binary event information.
 
 This replaces some of the tracing machinery we already had in the RTS:
 e.g. +RTS -vg  for GC tracing (we should do this using the new event
 logging instead).
 
 Event logging has almost no runtime cost when it isn't enabled, though
 in the future we might add more fine-grained events and this might
 change; hence having a link-time option and compiling a separate
 version of the RTS for event logging.  There's a small runtime cost
 for enabling event-logging, for most programs it shouldn't make much
 difference.
 
 (Todo: docs)
] 
[FIX biographical profiling (#3039, probably #2297)
Simon Marlow <marlowsd@gmail.com>**20090317144939
 Ignore-this: 3b1d53fdf0f99c04e7d0055534baf52f
 Since we introduced pointer tagging, we no longer always enter a
 closure to evaluate it.  However, the biographical profiler relies on
 closures being entered in order to mark them as "used", so we were
 getting spurious amounts of data attributed to VOID.  It turns out
 there are various places that need to be fixed, and I think at least
 one of them was also wrong before pointer tagging (CgCon.cgReturnDataCon).
] 
[Add getNumberOfProcessors(), FIX MacOS X build problem (hopefully)
Simon Marlow <marlowsd@gmail.com>**20090317093309
 Ignore-this: 3de51351864f7276f3f887cca5385294
 Somebody needs to implement getNumberOfProcessors() for MacOS X,
 currently it will return 1.
] 
[FIX #3093: stub filenames when using -osuf
Simon Marlow <marlowsd@gmail.com>**20090316203437
 Ignore-this: 999de35952804c760462ae32cfdd04d5
 Also remove some unused cruft
] 
[Don't call processHeapClosureForDead on pinned blocks
Simon Marlow <marlowsd@gmail.com>**20090316160534
 Ignore-this: 33a60e4ce78db6cc5bab399ec673ad0a
 Fixes heapprof001(prof_hp) after fix for #2917
] 
[Retract Hp *before* checking for HpLim==0
Simon Marlow <marlowsd@gmail.com>**20090316160500
 Ignore-this: f8fdb26c724f766cfae016321be101c4
 Fixes heapprof001(prof_hp) following the recent HpLim patch, which
 depended on the lack of slop in the heap.
] 
[eliminate some not-quite-duplicate code
Simon Marlow <marlowsd@gmail.com>**20090313155619
 Ignore-this: 2edadf2f966bf37868b355da1faa211c
] 
[start finalizers on the current Capability rather than last_free_capability
Simon Marlow <marlowsd@gmail.com>**20090313155602
 Ignore-this: b3e7bc2a7966cd5778e55a0e5dc83553
] 
[cope with ThreadRelocated on the sleeping_queue
Simon Marlow <marlowsd@gmail.com>**20090217132757
 Ignore-this: 6b73d2b2e4142d7db4e7db4570f644ff
] 
[Fix Trac #3095, and make RdrHsSyn warning-clean
simonpj@microsoft.com**20090316174706
 Ignore-this: db47522307c92d93e0037143dee74375
] 
[Layout only
simonpj@microsoft.com**20090316164619
 Ignore-this: af7c9018e873b1618bfe4a2f3102a0c7
] 
[Reject foralls in constructor args in 'deriving', except for Functor etc
simonpj@microsoft.com**20090316164502
 Ignore-this: 2538aee2634fb587d74a8dc1a064cb5b
] 
[Fix Trac #3092
simonpj@microsoft.com**20090316164049
 Ignore-this: 9502fdd84b7b1849f6c37afe12d46d64
 
 We were't checking that a 'data/type instance' was extending a family
 type constructor.
 
 Merge to 6.10 if we ever release 6.10.3 (or do it for 6.10.2).
 
 
] 
[Ensure the orientation of var-var equalities is correct for instatiation
Manuel M T Chakravarty <chak@cse.unsw.edu.au>**20090315065709
 Ignore-this: 95cf805dde74e0b9ff36a7fe7556ed1a
 - During fianlisation we use to occasionally swivel variable-variable equalities
 - Now, normalisation ensures that they are always oriented as appropriate for
   instantation.
 - Also fixed #1899 properly; the previous fix fixed a symptom, not the cause.
] 
[Use work-stealing for load-balancing in the GC
Simon Marlow <marlowsd@gmail.com>**20090313135116
 Ignore-this: d05027217c516de3d75f4d1844c860fd
   
 New flag: "+RTS -qb" disables load-balancing in the parallel GC
 (though this is subject to change, I think we will probably want to do
 something more automatic before releasing this).
 
 To get the "PARGC3" configuration described in the "Runtime support
 for Multicore Haskell" paper, use "+RTS -qg0 -qb -RTS".
 
 The main advantage of this is that it allows us to easily disable
 load-balancing altogether, which turns out to be important in parallel
 programs.  Maintaining locality is sometimes more important that
 spreading the work out in parallel GC.  There is a side benefit in
 that the parallel GC should have improved locality even when
 load-balancing, because each processor prefers to take work from its
 own queue before stealing from others.
] 
[Fix Trac #3087: derived Data now defines dataCast1/2
simonpj@microsoft.com**20090313134436
 Ignore-this: df43405a2ef5adef20f9eb3675e7411f
 
 This patch generates code in deriving(Data) for dataCast1 or 2 as
 appropriate.
 
 While I was there I did some refactoring (of course), pulling out
 the TcDeriv.inferConstraints as a separate function.
 
 I don't think it's worth merging this to 6.10.2, even though it's a bugfix,
 because it modifies code that I added in the HEAD only (for deriving Functor)
 so the merge will be sligtly awkward.  And there's an easy workaround.
 
] 
[Adjust error message slightly to make it clearer
simonpj@microsoft.com**20090313134402
 Ignore-this: 46b0abb88c1fe11cd4ff059955b81561
] 
[just comment formatting
Simon Marlow <marlowsd@gmail.com>**20090313132339
 Ignore-this: f53b0dca0896134dd704fc3aca3ea93f
] 
[Add "+RTS -N" to determine the -N value automatically (see #1741)
Simon Marlow <marlowsd@gmail.com>**20090313114646
 Ignore-this: b5dd21278e02f4a161093466ca97dce
] 
[tidy up "missing symbol" error message
Simon Marlow <marlowsd@gmail.com>**20090313101334] 
[Fix sanity checking after fix to #2917
Simon Marlow <marlowsd@gmail.com>**20090312093855] 
[Instead of a separate context-switch flag, set HpLim to zero
Simon Marlow <marlowsd@gmail.com>**20090313104516
 Ignore-this: 6c5bbe1ce2c5ef551efe98f288483b0
 This reduces the latency between a context-switch being triggered and
 the thread returning to the scheduler, which in turn should reduce the
 cost of the GC barrier when there are many cores.
 
 We still retain the old context_switch flag which is checked at the
 end of each block of allocation.  The idea is that setting HpLim may
 fail if the the target thread is modifying HpLim at the same time; the
 context_switch flag is a fallback.  It also allows us to "context
 switch soon" without forcing an immediate switch, which can be costly.
] 
[TAG 2009-03-13
Ian Lynagh <igloo@earth.li>**20090313021251] 
Patch bundle hash:
b2433717cebe0927bc64a992c34a15c16ba0c167