Fri Jul 17 21:56:44 BST 2009 Max Bolingbroke * Checkpoint working implementation of tuple sections Fri Jul 17 22:09:39 BST 2009 Max Bolingbroke * Improvements to the tuple section parser Fri Jul 17 22:23:14 BST 2009 Max Bolingbroke * Support unboxed tuples in tuple sections Fri Jul 17 22:40:31 BST 2009 Max Bolingbroke * Documentation for tuple sections Fri Jul 17 23:31:42 BST 2009 Max Bolingbroke * Fix validation failure caused by tuple sections New patches: [Checkpoint working implementation of tuple sections Max Bolingbroke **20090717205644 Ignore-this: 50eb87a80b944f116d685b704efb5e35 ] { hunk ./compiler/deSugar/Coverage.lhs 27 import StaticFlags import TyCon import FiniteMap +import Maybes import Data.Array hunk ./compiler/deSugar/Coverage.lhs 30 -import Data.Maybe import System.Directory ( createDirectoryIfMissing ) import Trace.Hpc.Mix hunk ./compiler/deSugar/Coverage.lhs 281 liftM2 SectionR (addTickLHsExpr e1) (addTickLHsExpr e2) +addTickHsExpr (SectionTup tys mb_es boxity) = + liftM3 SectionTup + (return tys) + (mapM (fmapM_maybe addTickLHsExpr) mb_es) + (return boxity) addTickHsExpr (HsCase e mgs) = liftM2 HsCase (addTickLHsExpr e) hunk ./compiler/deSugar/Coverage.lhs 309 ListComp -> Just $ BinBox QualBinBox _ -> Nothing addTickHsExpr (ExplicitList ty es) = - liftM2 ExplicitList + liftM2 ExplicitList (return ty) (mapM (addTickLHsExpr) es) addTickHsExpr (ExplicitPArr ty es) = hunk ./compiler/deSugar/DsExpr.lhs 264 return (bindNonRec y_id y_core $ Lam x_id (mkCoreAppsDs core_op [Var x_id, Var y_id])) +dsExpr (SectionTup tys mb_exprs boxity) = do + let go (lam_vars, args) (ty, Nothing) = do + -- For every missing expression, we need another lambda in the desugaring. + lam_var <- newSysLocalDs ty + return (lam_var : lam_vars, Var lam_var : args) + go (lam_vars, args) (_, Just expr) = do + -- Expressions that are present don't generate lambdas, just arguments. + core_expr <- dsLExpr expr + return (lam_vars, core_expr : args) + (lam_vars, args) <- foldM go ([], []) (tys `zip` mb_exprs) + return $ mkCoreLams (reverse lam_vars) $ mkConApp (tupleCon boxity (length mb_exprs)) + (map Type tys ++ reverse args) + dsExpr (HsSCC cc expr) = do mod_name <- getModuleDs Note (SCC (mkUserCC cc mod_name)) <$> dsLExpr expr hunk ./compiler/deSugar/DsMeta.hs 686 repE (HsPar x) = repLE x repE (SectionL x y) = do { a <- repLE x; b <- repLE y; repSectionL a b } repE (SectionR x y) = do { a <- repLE x; b <- repLE y; repSectionR a b } +repE e@(SectionTup _ _ _) = notHandled "Tuple sections" (ppr e) repE (HsCase e (MatchGroup ms _)) = do { arg <- repLE e ; ms2 <- mapM repMatchTup ms ; repCaseE arg (nonEmptyCoreList ms2) } hunk ./compiler/deSugar/Match.lhs 884 -- if it seems useful (lams and lets) wrap _ _ = False + liftMaybe2 f (Just x) (Just y) = Just $ f x y + liftMaybe2 _ _ _ = Nothing + -- real comparison is on HsExpr's -- strip parens exp (HsPar (L _ e)) e' = exp e e' hunk ./compiler/deSugar/Match.lhs 918 lexp e1 e1' && lexp e2 e2' exp (SectionR e1 e2) (SectionR e1' e2') = lexp e1 e1' && lexp e2 e2' + exp (SectionTup _ mb_es1 _) (SectionTup _ mb_es2 _) = + all ((`orElse` False) . uncurry (liftMaybe2 lexp)) (mb_es1 `zip` mb_es2) exp (HsIf e e1 e2) (HsIf e' e1' e2') = lexp e e' && lexp e1 e1' && lexp e2 e2' exp (ExplicitList _ ls) (ExplicitList _ ls') = lexps ls ls' hunk ./compiler/deSugar/Match.lhs 924 exp (ExplicitPArr _ ls) (ExplicitPArr _ ls') = lexps ls ls' - exp (ExplicitTuple ls _) (ExplicitTuple ls' _) = lexps ls ls' -- Enhancement: could implement equality for more expressions -- if it seems useful exp _ _ = False hunk ./compiler/hsSyn/HsExpr.lhs 27 import SrcLoc import Outputable import FastString +import Maybes \end{code} hunk ./compiler/hsSyn/HsExpr.lhs 124 (LHsExpr id) -- operator | SectionR (LHsExpr id) -- operator (LHsExpr id) -- operand + | SectionTup [PostTcType] -- types of components + [Maybe (LHsExpr id)] -- At least one of the components is Nothing. + -- Used for the TupleSections extension: + -- + -- >>> (1,,3) 2 + -- (1, 2, 3) + Boxity | HsCase (LHsExpr id) (MatchGroup id) hunk ./compiler/hsSyn/HsExpr.lhs 161 | ExplicitTuple -- tuple [LHsExpr id] -- NB: Unit is ExplicitTuple [] - -- for tuples, we can get the types - -- direct from the components Boxity hunk ./compiler/hsSyn/HsExpr.lhs 389 pp_infixly v = (sep [pprHsInfix v, pp_expr]) +ppr_expr (SectionTup _ mb_exprs boxity) + = tupleParens boxity (sep (punctuate comma (map ((`orElse` empty) . fmap ppr_lexpr) mb_exprs))) + --avoid using PatternSignatures for stage1 code portability ppr_expr exprType@(HsLam matches) = pprMatches (LambdaExpr `asTypeOf` idType exprType) matches hunk ./compiler/hsSyn/HsExpr.lhs 547 HsOverLit _ -> pp_as_was HsVar _ -> pp_as_was HsIPVar _ -> pp_as_was + SectionTup _ _ _ -> pp_as_was ExplicitList _ _ -> pp_as_was ExplicitPArr _ _ -> pp_as_was ExplicitTuple _ _ -> pp_as_was hunk ./compiler/main/DynFlags.hs 252 | Opt_GeneralizedNewtypeDeriving | Opt_RecursiveDo | Opt_PostfixOperators + | Opt_TupleSections | Opt_PatternGuards | Opt_LiberalTypeSynonyms | Opt_Rank2Types hunk ./compiler/main/DynFlags.hs 1770 xFlags = [ ( "CPP", Opt_Cpp, const Supported ), ( "PostfixOperators", Opt_PostfixOperators, const Supported ), + ( "TupleSections", Opt_TupleSections, const Supported ), ( "PatternGuards", Opt_PatternGuards, const Supported ), ( "UnicodeSyntax", Opt_UnicodeSyntax, const Supported ), ( "MagicHash", Opt_MagicHash, const Supported ), hunk ./compiler/parser/Parser.y.pp 1340 -- (you'd have to write '((+ 3), (4 -))') -- but the less cluttered version fell out of having texps. | '(' texp ')' { LL (HsPar $2) } - | '(' texp ',' texps ')' { LL $ ExplicitTuple ($2 : reverse $4) Boxed } - | '(#' texps '#)' { LL $ ExplicitTuple (reverse $2) Unboxed } + | '(' texp tuplesectend { LL $ mkTuplish (Just $2 : unLoc $3) Boxed } + | '(' commas texp ')' { LL $ mkTuplish (replicate $2 Nothing ++ [Just $3]) Boxed } + | '(' commas texp tuplesectend { LL $ mkTuplish (replicate $2 Nothing ++ Just $3 : unLoc $4) Boxed } + | '(#' texps '#)' { LL $ ExplicitTuple (reverse $2) Unboxed } | '[' list ']' { LL (unLoc $2) } | '[:' parr ':]' { LL (unLoc $2) } | '_' { L1 EWildPat } hunk ./compiler/parser/Parser.y.pp 1415 : texps ',' texp { $3 : $1 } | texp { [$1] } +tuplesectend :: { Located [Maybe (LHsExpr RdrName)] } + : commas texp tuplesectend { sL (comb2 $2 $>) $ replicate ($1 - 1) Nothing ++ Just $2 : unLoc $3 } + | commas texp ')' { sL (comb2 $2 $>) $ replicate ($1 - 1) Nothing ++ [Just $2] } + | commas ')' { sL (comb2 $2 $>) $ replicate $1 Nothing } ----------------------------------------------------------------------------- -- List expressions hunk ./compiler/parser/Parser.y.pp 1666 sysdcon :: { Located DataCon } -- Wired in data constructors : '(' ')' { LL unitDataCon } - | '(' commas ')' { LL $ tupleCon Boxed $2 } + | '(' commas ')' { LL $ tupleCon Boxed ($2 + 1) } | '(#' '#)' { LL $ unboxedSingletonDataCon } hunk ./compiler/parser/Parser.y.pp 1668 - | '(#' commas '#)' { LL $ tupleCon Unboxed $2 } + | '(#' commas '#)' { LL $ tupleCon Unboxed ($2 + 1) } | '[' ']' { LL nilDataCon } conop :: { Located RdrName } hunk ./compiler/parser/Parser.y.pp 1685 gtycon :: { Located RdrName } -- A "general" qualified tycon : oqtycon { $1 } | '(' ')' { LL $ getRdrName unitTyCon } - | '(' commas ')' { LL $ getRdrName (tupleTyCon Boxed $2) } + | '(' commas ')' { LL $ getRdrName (tupleTyCon Boxed ($2 + 1)) } | '(#' '#)' { LL $ getRdrName unboxedSingletonTyCon } hunk ./compiler/parser/Parser.y.pp 1687 - | '(#' commas '#)' { LL $ getRdrName (tupleTyCon Unboxed $2) } + | '(#' commas '#)' { LL $ getRdrName (tupleTyCon Unboxed ($2 + 1)) } | '(' '->' ')' { LL $ getRdrName funTyCon } | '[' ']' { LL $ listTyCon_RDR } | '[:' ':]' { LL $ parrTyCon_RDR } hunk ./compiler/parser/Parser.y.pp 1896 commas :: { Int } : commas ',' { $1 + 1 } - | ',' { 2 } + | ',' { 1 } ----------------------------------------------------------------------------- -- Documentation comments hunk ./compiler/parser/RdrHsSyn.lhs 17 mkClassDecl, mkTyData, mkTyFamily, mkTySynonym, splitCon, mkInlineSpec, mkRecConstrOrUpdate, -- HsExp -> [HsFieldUpdate] -> P HsExp + mkTuplish, cvBindGroup, cvBindsAndSigs, hunk ./compiler/parser/RdrHsSyn.lhs 63 import RdrName ( RdrName, isRdrTyVar, isRdrTc, mkUnqual, rdrNameOcc, isRdrDataCon, isUnqual, getRdrName, isQual, setRdrNameSpace, showRdrName ) -import BasicTypes ( maxPrecedence, Activation, RuleMatchInfo, +import BasicTypes ( maxPrecedence, Boxity, Activation, RuleMatchInfo, InlinePragma(..), InlineSpec(..), alwaysInlineSpec, neverInlineSpec ) import Lexer ( P, failSpanMsgP, extension, standaloneDerivingEnabled, bangPatEnabled ) hunk ./compiler/parser/RdrHsSyn.lhs 81 import List ( isSuffixOf, nubBy ) +import Data.Maybe + #include "HsVersions.h" \end{code} hunk ./compiler/parser/RdrHsSyn.lhs 965 -- NOINLINE mkInlineSpec (Just act) match_info inl = Inline (InlinePragma act match_info) inl +mkTuplish :: [Maybe (LHsExpr RdrName)] -> Boxity -> HsExpr RdrName +mkTuplish mb_exprs | all isJust mb_exprs = ExplicitTuple (map fromJust mb_exprs) + | otherwise = SectionTup [placeHolderType | _ <- mb_exprs] mb_exprs ----------------------------------------------------------------------------- -- utilities for foreign declarations hunk ./compiler/rename/RnExpr.lhs 47 import List ( nub ) import Util ( isSingleton ) import ListSetOps ( removeDups ) -import Maybes ( expectJust ) +import Maybes ( expectJust, fmapM_maybe ) import Outputable import SrcLoc import FastString hunk ./compiler/rename/RnExpr.lhs 242 = rnExprs exps `thenM` \ (exps', fvs) -> return (ExplicitPArr placeHolderType exps', fvs) -rnExpr (ExplicitTuple exps boxity) +rnExpr e@(ExplicitTuple exps boxity) = checkTupSize (length exps) `thenM_` hunk ./compiler/rename/RnExpr.lhs 244 - rnExprs exps `thenM` \ (exps', fvs) -> + rnExprs exps `thenM` \ (exps', fvs) -> return (ExplicitTuple exps' boxity, fvs) hunk ./compiler/rename/RnExpr.lhs 247 +rnExpr e@(SectionTup tys mb_exps boxity) + = checkTupleSection e `thenM_` + checkTupSize (length mb_exps) `thenM_` + mapM (fmapM_maybe rnLExpr) mb_exps `thenM` \mb_expsfvs -> + let commuteJustPair Nothing = (Nothing, Nothing) + commuteJustPair (Just (x, y)) = (Just x, Just y) + + (mb_exps', mb_fvs) = unzip $ map commuteJustPair mb_expsfvs + in return (SectionTup tys mb_exps' boxity, plusFVs [fvs | Just fvs <- mb_fvs]) + rnExpr (RecordCon con_id _ rbinds) = do { conname <- lookupLocatedOccRn con_id ; (rbinds', fvRbinds) <- rnHsRecFields_Con conname rnLExpr rbinds hunk ./compiler/rename/RnExpr.lhs 1206 checkTransformStmt ctxt = addErr msg where msg = ptext (sLit "Illegal transform or grouping in") <+> pprStmtContext ctxt - + +--------- +checkTupleSection :: HsExpr RdrName -> RnM () +checkTupleSection _ + = do { tuple_section <- doptM Opt_TupleSections + ; checkErr tuple_section msg } + where + msg = ptext (sLit "Illegal tuple section: use -XTupleSections") + --------- sectionErr :: HsExpr RdrName -> SDoc sectionErr expr hunk ./compiler/typecheck/TcExpr.lhs 283 ; qtys' <- mapM refineBox qtys -- c.f. tcArgs ; return (qtys', arg2') } tc_args arg1_ty' _ _ _ = panic "tcExpr SectionR" + +tcExpr in_expr@(SectionTup _ mb_exprs boxity) res_ty + = do { let kind = case boxity of { Boxed -> liftedTypeKind + ; Unboxed -> argTypeKind } + arity = length mb_exprs + ; tvs <- newBoxyTyVars (replicate arity kind) + ; let tys = map mkTyVarTy tvs + tup_tc = tupleTyCon boxity arity + tup_res_ty = mkTyConApp tup_tc tys + ; checkWiredInTyCon tup_tc -- Ensure instances are available + + ; let go Nothing ty = return (Just ty, Nothing) + go (Just expr) ty = do + expr' <- tcMonoExpr expr ty + return (Nothing, Just expr') + ; (mb_arg_tys, mb_exprs') <- mapAndUnzipM (uncurry go) (mb_exprs `zip` tys) + + ; boxyUnify ([arg_ty | Just arg_ty <- mb_arg_tys] `mkFunTys` tup_res_ty) res_ty + + ; return (SectionTup tys mb_exprs' boxity) } \end{code} \begin{code} hunk ./compiler/typecheck/TcHsSyn.lhs 493 zonkLExpr env expr `thenM` \ new_expr -> returnM (SectionR new_op new_expr) +zonkExpr env (SectionTup tys mb_exprs boxed) + = zonkTcTypeToTypes env tys `thenM` \ new_tys -> + mapM (fmapM_maybe (zonkLExpr env)) mb_exprs `thenM` \ new_mb_exprs -> + returnM (SectionTup new_tys new_mb_exprs boxed) + zonkExpr env (HsCase expr ms) = zonkLExpr env expr `thenM` \ new_expr -> zonkMatchGroup env ms `thenM` \ new_ms -> hunk ./compiler/utils/Maybes.lhs 13 MaybeErr(..), -- Instance of Monad failME, isSuccess, + fmapM_maybe, orElse, mapCatMaybes, allMaybes, hunk ./compiler/utils/Maybes.lhs 78 Nothing `orElse` y = y \end{code} +\begin{code} +fmapM_maybe :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) +fmapM_maybe _ Nothing = return Nothing +fmapM_maybe f (Just x) = do + x' <- f x + return $ Just x' +\end{code} + %************************************************************************ %* * \subsection[MaybeT type]{The @MaybeT@ monad transformer} } [Improvements to the tuple section parser Max Bolingbroke **20090717210939 Ignore-this: 58618a5a21b7ab68cde92ba3eae9441f ] { hunk ./compiler/parser/Parser.y.pp 1339 -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't correct Haskell98 -- (you'd have to write '((+ 3), (4 -))') -- but the less cluttered version fell out of having texps. - | '(' texp ')' { LL (HsPar $2) } - | '(' texp tuplesectend { LL $ mkTuplish (Just $2 : unLoc $3) Boxed } - | '(' commas texp ')' { LL $ mkTuplish (replicate $2 Nothing ++ [Just $3]) Boxed } - | '(' commas texp tuplesectend { LL $ mkTuplish (replicate $2 Nothing ++ Just $3 : unLoc $4) Boxed } + | '(' mbtexps ')' { LL $ mkTuplish (unLoc $2) Boxed } + | '(' commas mbtexps ')' { LL $ mkTuplish (replicate $2 Nothing ++ unLoc $3) Boxed } | '(#' texps '#)' { LL $ ExplicitTuple (reverse $2) Unboxed } | '[' list ']' { LL (unLoc $2) } | '[:' parr ':]' { LL (unLoc $2) } hunk ./compiler/parser/Parser.y.pp 1413 : texps ',' texp { $3 : $1 } | texp { [$1] } -tuplesectend :: { Located [Maybe (LHsExpr RdrName)] } - : commas texp tuplesectend { sL (comb2 $2 $>) $ replicate ($1 - 1) Nothing ++ Just $2 : unLoc $3 } - | commas texp ')' { sL (comb2 $2 $>) $ replicate ($1 - 1) Nothing ++ [Just $2] } - | commas ')' { sL (comb2 $2 $>) $ replicate $1 Nothing } +mbtexps :: { Located [Maybe (LHsExpr RdrName)] } + : texp commas mbtexps { LL $ Just $1 : replicate ($2 - 1) Nothing ++ unLoc $3 } + | texp commas { L1 $ Just $1 : replicate $2 Nothing } + | texp { L1 [Just $1] } ----------------------------------------------------------------------------- -- List expressions hunk ./compiler/parser/RdrHsSyn.lhs 63 import RdrName ( RdrName, isRdrTyVar, isRdrTc, mkUnqual, rdrNameOcc, isRdrDataCon, isUnqual, getRdrName, isQual, setRdrNameSpace, showRdrName ) -import BasicTypes ( maxPrecedence, Boxity, Activation, RuleMatchInfo, +import BasicTypes ( maxPrecedence, Boxity(..), Activation, RuleMatchInfo, InlinePragma(..), InlineSpec(..), alwaysInlineSpec, neverInlineSpec ) import Lexer ( P, failSpanMsgP, extension, standaloneDerivingEnabled, bangPatEnabled ) hunk ./compiler/parser/RdrHsSyn.lhs 966 mkInlineSpec (Just act) match_info inl = Inline (InlinePragma act match_info) inl mkTuplish :: [Maybe (LHsExpr RdrName)] -> Boxity -> HsExpr RdrName -mkTuplish mb_exprs | all isJust mb_exprs = ExplicitTuple (map fromJust mb_exprs) - | otherwise = SectionTup [placeHolderType | _ <- mb_exprs] mb_exprs +mkTuplish mb_exprs bxty + | non_section, length mb_exprs == 1, bxty == Boxed = HsPar (fromJust $ head mb_exprs) + | non_section = ExplicitTuple (map fromJust mb_exprs) bxty + | otherwise = SectionTup [placeHolderType | _ <- mb_exprs] mb_exprs bxty + where non_section = all isJust mb_exprs ----------------------------------------------------------------------------- -- utilities for foreign declarations } [Support unboxed tuples in tuple sections Max Bolingbroke **20090717212314 Ignore-this: 5534505d30a27cc53983d76c31639066 ] { hunk ./compiler/parser/Parser.y.pp 1341 -- but the less cluttered version fell out of having texps. | '(' mbtexps ')' { LL $ mkTuplish (unLoc $2) Boxed } | '(' commas mbtexps ')' { LL $ mkTuplish (replicate $2 Nothing ++ unLoc $3) Boxed } - | '(#' texps '#)' { LL $ ExplicitTuple (reverse $2) Unboxed } + | '(#' mbtexps '#)' { LL $ mkTuplish (unLoc $2) Unboxed } + | '(#' commas mbtexps '#)' { LL $ mkTuplish (replicate $2 Nothing ++ unLoc $3) Unboxed } | '[' list ']' { LL (unLoc $2) } | '[:' parr ':]' { LL (unLoc $2) } | '_' { L1 EWildPat } hunk ./compiler/parser/Parser.y.pp 1410 -- View patterns get parenthesized above | exp '->' exp { LL $ EViewPat $1 $3 } -texps :: { [LHsExpr RdrName] } - : texps ',' texp { $3 : $1 } - | texp { [$1] } - mbtexps :: { Located [Maybe (LHsExpr RdrName)] } : texp commas mbtexps { LL $ Just $1 : replicate ($2 - 1) Nothing ++ unLoc $3 } | texp commas { L1 $ Just $1 : replicate $2 Nothing } } [Documentation for tuple sections Max Bolingbroke **20090717214031 Ignore-this: 88e88215e5905622464a0e5cdb813f13 ] hunk ./docs/users_guide/glasgow_exts.xml 1272 + +Tuple sections + + + The flag enables Python-style partially applied + tuple constructors. For example, the following program + + (, True) + + is considered to be an alternative notation for the more unwieldy alternative + + \x -> (x, True) + +You can omit any combination of arguments to the tuple, as in the following + + (, "I", , , "Love", , 1337) + +which translates to + + \a b c d -> (a, "I", b, c, "Love", d, 1337) + + + + + If you have unboxed tuples enabled, tuple sections + will also be available for them, like so + + (# , True #) + +Because there is no unboxed unit tuple, the following expression + + (# #) + +continues to stand for the unboxed singleton tuple data constructor. + + + + Record field disambiguation [Fix validation failure caused by tuple sections Max Bolingbroke **20090717223142 Ignore-this: 266893eac2eb1c3eab0b5de55d922a3f ] hunk ./compiler/rename/RnExpr.lhs 242 = rnExprs exps `thenM` \ (exps', fvs) -> return (ExplicitPArr placeHolderType exps', fvs) -rnExpr e@(ExplicitTuple exps boxity) +rnExpr (ExplicitTuple exps boxity) = checkTupSize (length exps) `thenM_` rnExprs exps `thenM` \ (exps', fvs) -> return (ExplicitTuple exps' boxity, fvs) Context: [Fix Trac #3346: tcSimplify for LHS of RULES with type equalities simonpj@microsoft.com**20090717155722 Ignore-this: dfdd0f9a62d78d63276a4d558831099c ] [Allow mixed case in the LINE pragma; patch from squadette; fixes #1817 Ian Lynagh **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] [Typo fixes, from Alexey Mahotkin Ian Lynagh **20090717010817] [Use names like '$fOrdInt' for dfuns (and TF instances), rather than '$f21' Simon Marlow **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 **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. ] [Don't put all of $CFLAGS into $SRC_CC_OPTS Ian Lynagh **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 **20090716005314] [Make the --info values printable with "ghc --print-foo"; trac #3122 Ian Lynagh **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. ] [whitespace only Simon Marlow **20090716104217 Ignore-this: 38cff291d9ef15c30e3ed685ffc3c9f9 ] [refactor: use packageConfigId in place of mkPackageId . package Simon Marlow **20090716104145 Ignore-this: f3d73e7bd1b307a67d26585c49f3d89f ] [Fix a flag name in the docs Ian Lynagh **20090714165943] [Add the -fno-shared-implib flag Ian Lynagh **20090714165631 Patch from Max Bolingbroke 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 **20090713083524 Ignore-this: 500077008e463532e0677ee82f5284bb ] [Simplify timestamp restoration Matthias Kilian **20090711100244 Ignore-this: 7eaede224befa6b5368c91b92366211 ] [FIX #3272 Manuel M T Chakravarty **20090714054559 Ignore-this: 225fe4d82d4eed02e9b1377687661bac ] [Fix warnings Roman Leshchinskiy **20090713092032 Ignore-this: 3631b87164fc54d82e3a02875dc08f7d ] [Separate length from data in DPH arrays Roman Leshchinskiy **20090713044212 Ignore-this: aa2cc3b5ae43bd2c493ce4b330c883cd ] [Stop using -fno-warn-unused-do-bind when compiling the libraries Ian Lynagh **20090709160422 They're now fixed to not generate those warnings ] [Remove maybePrefixMatch, using stripPrefix instead Ian Lynagh **20090709160412 We already require GHC 6.8 to build, and that included stripPrefix in Data.List. ] [TFs: FIX #2203 (second half) Manuel M T Chakravarty **20090710064834 Ignore-this: 46a46feaa73f74feb08524b9e7547414 ] [TFs: Fix should_compile/Simple8 Manuel M T Chakravarty **20090710042728 Ignore-this: 471ab67e3df1c5245921be5286a45f93 ] [workaround new Cygwin bash CRLF behaviour Simon Marlow **20090709132850 Ignore-this: 5cfa2cc9d776ebe315c0f6ad7ab56d98 ] [Use /usr/bin/test if it exists, and fix test syntax. Simon Marlow **20090709124616 Ignore-this: 83a75ba7c3ce2a1d02bddb7bfe414bfe Should fix Solaris build failures ] [Allow mixed case pragmas; #1817. Patch from squadette Ian Lynagh **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- Simon Marlow **20090706092031 Ignore-this: 2584d7bf56e77b27ca5b7b557c152c5e ] [Fix ignored-monadic-result warnings Ian Lynagh **20090707181857] [Fix an unused import warning Ian Lynagh **20090707144706] [Fix unused import warnings Ian Lynagh **20090707143216] [Fix unused import warnings Ian Lynagh **20090707133537] [When exporting F(..), all the children of F are also exported Ian Lynagh **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 **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 ] [Avoid unnecessary recompilation after ./configure (helps #3228) Simon Marlow **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 **20090707081845 Ignore-this: 6073db47eafd52e13e76c58ef738afcf ] [remove tabs Simon Marlow **20090707081823 Ignore-this: 3d65831fc019f76cefac03291904842a ] [fix cleaning of libraries (now 'make clean' in libraries/* works again) Simon Marlow **20090703114638 Ignore-this: b3af731d50ff5bfbd453f94aa40cb92c ] [FIX #2677 Manuel M T Chakravarty **20090707055442 Ignore-this: e224dd09d0d1c9ec4f3b46c7accb8d57 ] [Update driver/Makefile for the new build system Ian Lynagh **20090705204041] [Fix generational GC bug (#3348) Simon Marlow **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. ] [Follow Cabal changes Ian Lynagh **20090705180414] [Update TODO list Ian Lynagh **20090705165009] [Make -fext-core a dynamic flag (it was a static flag) Ian Lynagh **20090705132420] [Update a few points about shared libs in other sections Duncan Coutts **20090704212212 And add links to the new shared libs section. ] [Document -dynload flag. Also add it and -shared to the flags reference. Duncan Coutts **20090704212119] [Add new section on using shared libs Duncan Coutts **20090704212003] [Document foreign import prim in the user guide Duncan Coutts **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 **20090704210654] [Make changes to -fwarn-unused-do-bind and -fwarn-wrong-do-bind suggested by SPJ Max Bolingbroke **20090702150943 Ignore-this: 595368298d2e11623c0bd280ff89d8de ] [Support for -fwarn-unused-do-bind and -fwarn-wrong-do-bind, as per #3263 Max Bolingbroke **20090701200344 Ignore-this: 511117ffc10d4b656e530b751559b8b8 ] [Improved infrastructure for fast-rebuilding of parts of the tree Simon Marlow **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 **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 **20090702070905 Ignore-this: ebf829f0ae025e82bccdfa4345828ffe ] [Fix #2197 (properly this time) Simon Marlow **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 **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 **20090701110609 Ignore-this: f326ec8931d0d484a66b67ce1270cc6e ] ['make html' in a library builds the Haddock docs Simon Marlow **20090630111137 Ignore-this: 781bf10e2d4bca23b7f70c6f0465d120 ] [fix GC bug introduced with the C finalizer support Simon Marlow **20090630080834 Ignore-this: 3567e3adb5ae4a5dcbce81733487f348 ] [Add a configure test for whether or not __mingw_vfprintf exists Ian Lynagh **20090627150501] [Fix #3319, and do various tidyups at the same time Simon Marlow **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 **20090626131410 Ignore-this: 187091bbe78f2b14402162acfb98180f ] [TAG 2009-06-25 Ian Lynagh **20090625155528] Patch bundle hash: 7fff8869fef84913c865a9c552e6e3ddb83dbe69