X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2FdeSugar%2FDsUtils.lhs;h=3a976878e3ead7625a96703c5621a5ae8bec3f0a;hp=6bc70e2b8f56932cbe3ab2d2d3e83277ce65e896;hb=f2aaae9757e7532485c97f6c9a9ed5437542d1dd;hpb=8100cd4395e46ae747be4298c181a4730d6206bc diff --git a/compiler/deSugar/DsUtils.lhs b/compiler/deSugar/DsUtils.lhs index 6bc70e2..3a97687 100644 --- a/compiler/deSugar/DsUtils.lhs +++ b/compiler/deSugar/DsUtils.lhs @@ -8,30 +8,31 @@ Utilities for desugaring This module exports some utility functions of no great interest. \begin{code} +-- | Utility functions for constructing Core syntax, principally for desugaring module DsUtils ( EquationInfo(..), firstPat, shiftEqns, - - mkDsLet, mkDsLets, MatchResult(..), CanItFail(..), cantFailMatchResult, alwaysFailMatchResult, extractMatchResult, combineMatchResults, adjustMatchResult, adjustMatchResultDs, - mkCoLetMatchResult, mkGuardedMatchResult, + mkCoLetMatchResult, mkViewMatchResult, mkGuardedMatchResult, matchCanFail, mkEvalMatchResult, mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, wrapBind, wrapBinds, - mkErrorAppDs, mkNilExpr, mkConsExpr, mkListExpr, - mkIntExpr, mkCharExpr, - mkStringExpr, mkStringExprFS, mkIntegerExpr, + mkErrorAppDs, mkCoreAppDs, mkCoreAppsDs, - mkSelectorBinds, mkTupleExpr, mkTupleSelector, - mkTupleType, mkTupleCase, mkBigCoreTup, - mkCoreTup, mkCoreTupTy, seqVar, - - dsSyntaxTable, lookupEvidence, + seqVar, + + -- LHs tuples + mkLHsVarPatTup, mkLHsPatTup, mkVanillaTuplePat, + mkBigLHsVarTup, mkBigLHsTup, mkBigLHsVarPatTup, mkBigLHsPatTup, + + mkSelectorBinds, + + dsSyntaxTable, lookupEvidence, selectSimpleMatchVarL, selectMatchVars, selectMatchVar, mkTickBox, mkOptTickBox, mkBinaryTickBox @@ -44,11 +45,12 @@ import {-# SOURCE #-} DsExpr( dsExpr ) import HsSyn import TcHsSyn +import TcType( tcSplitTyConApp ) import CoreSyn -import Constants import DsMonad import CoreUtils +import MkCore import MkId import Id import Var @@ -69,12 +71,7 @@ import SrcLoc import Util import ListSetOps import FastString -import Data.Char -import DynFlags - -#ifdef DEBUG -import Util -#endif +import StaticFlags \end{code} @@ -90,48 +87,25 @@ dsSyntaxTable :: SyntaxTable Id -> DsM ([CoreBind], -- Auxiliary bindings [(Name,Id)]) -- Maps the standard name to its value -dsSyntaxTable rebound_ids - = mapAndUnzipDs mk_bind rebound_ids `thenDs` \ (binds_s, prs) -> +dsSyntaxTable rebound_ids = do + (binds_s, prs) <- mapAndUnzipM mk_bind rebound_ids return (concat binds_s, prs) where - -- The cheapo special case can happen when we - -- make an intermediate HsDo when desugaring a RecStmt + -- The cheapo special case can happen when we + -- make an intermediate HsDo when desugaring a RecStmt mk_bind (std_name, HsVar id) = return ([], (std_name, id)) - mk_bind (std_name, expr) - = dsExpr expr `thenDs` \ rhs -> - newSysLocalDs (exprType rhs) `thenDs` \ id -> - return ([NonRec id rhs], (std_name, id)) + mk_bind (std_name, expr) = do + rhs <- dsExpr expr + id <- newSysLocalDs (exprType rhs) + return ([NonRec id rhs], (std_name, id)) lookupEvidence :: [(Name, Id)] -> Name -> Id lookupEvidence prs std_name = assocDefault (mk_panic std_name) prs std_name where - mk_panic std_name = pprPanic "dsSyntaxTable" (ptext SLIT("Not found:") <+> ppr std_name) + mk_panic std_name = pprPanic "dsSyntaxTable" (ptext (sLit "Not found:") <+> ppr std_name) \end{code} - -%************************************************************************ -%* * -\subsection{Building lets} -%* * -%************************************************************************ - -Use case, not let for unlifted types. The simplifier will turn some -back again. - -\begin{code} -mkDsLet :: CoreBind -> CoreExpr -> CoreExpr -mkDsLet (NonRec bndr rhs) body - | isUnLiftedType (idType bndr) - = Case rhs bndr (exprType body) [(DEFAULT,[],body)] -mkDsLet bind body - = Let bind body - -mkDsLets :: [CoreBind] -> CoreExpr -> CoreExpr -mkDsLets binds body = foldr mkDsLet body binds -\end{code} - - %************************************************************************ %* * \subsection{ Selecting match variables} @@ -166,15 +140,53 @@ selectSimpleMatchVarL pat = selectMatchVar (unLoc pat) selectMatchVars :: [Pat Id] -> DsM [Id] selectMatchVars ps = mapM selectMatchVar ps -selectMatchVar (BangPat pat) = selectMatchVar (unLoc pat) -selectMatchVar (LazyPat pat) = selectMatchVar (unLoc pat) -selectMatchVar (ParPat pat) = selectMatchVar (unLoc pat) -selectMatchVar (VarPat var) = return var -selectMatchVar (AsPat var pat) = return (unLoc var) -selectMatchVar other_pat = newSysLocalDs (hsPatType other_pat) +selectMatchVar :: Pat Id -> DsM Id +selectMatchVar (BangPat pat) = selectMatchVar (unLoc pat) +selectMatchVar (LazyPat pat) = selectMatchVar (unLoc pat) +selectMatchVar (ParPat pat) = selectMatchVar (unLoc pat) +selectMatchVar (VarPat var) = return (localiseId var) -- Note [Localise pattern binders] +selectMatchVar (AsPat var _) = return (unLoc var) +selectMatchVar other_pat = newSysLocalDs (hsPatType other_pat) -- OK, better make up one... \end{code} +Note [Localise pattern binders] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Consider module M where + [Just a] = e +After renaming it looks like + module M where + [Just M.a] = e + +We don't generalise, since it's a pattern binding, monomorphic, etc, +so after desugaring we may get something like + M.a = case e of (v:_) -> + case v of Just M.a -> M.a +Notice the "M.a" in the pattern; after all, it was in the original +pattern. However, after optimisation those pattern binders can become +let-binders, and then end up floated to top level. They have a +different *unique* by then (the simplifier is good about maintaining +proper scoping), but it's BAD to have two top-level bindings with the +External Name M.a, because that turns into two linker symbols for M.a. +It's quite rare for this to actually *happen* -- the only case I know +of is tc003 compiled with the 'hpc' way -- but that only makes it +all the more annoying. + +To avoid this, we craftily call 'localiseId' in the desugarer, which +simply turns the External Name for the Id into an Internal one, but +doesn't change the unique. So the desugarer produces this: + M.a{r8} = case e of (v:_) -> + case v of Just a{r8} -> M.a{r8} +The unique is still 'r8', but the binding site in the pattern +is now an Internal Name. Now the simplifier's usual mechanisms +will propagate that Name to all the occurrence sites, as well as +un-shadowing it, so we'll get + M.a{r8} = case e of (v:_) -> + case v of Just a{s77} -> a{s77} +In fact, even CoreSubst.simplOptExpr will do this, and simpleOptExpr +runs on the output of the desugarer, so all is well by the end of +the desugaring pass. + %************************************************************************ %* * @@ -188,7 +200,7 @@ worthy of a type synonym and a few handy functions. \begin{code} firstPat :: EquationInfo -> Pat Id -firstPat eqn = head (eqn_pats eqn) +firstPat eqn = ASSERT( notNull (eqn_pats eqn) ) head (eqn_pats eqn) shiftEqns :: [EquationInfo] -> [EquationInfo] -- Drop the first pattern in each equation @@ -203,69 +215,73 @@ matchCanFail (MatchResult CanFail _) = True matchCanFail (MatchResult CantFail _) = False alwaysFailMatchResult :: MatchResult -alwaysFailMatchResult = MatchResult CanFail (\fail -> returnDs fail) +alwaysFailMatchResult = MatchResult CanFail (\fail -> return fail) cantFailMatchResult :: CoreExpr -> MatchResult -cantFailMatchResult expr = MatchResult CantFail (\ ignore -> returnDs expr) +cantFailMatchResult expr = MatchResult CantFail (\_ -> return expr) extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr -extractMatchResult (MatchResult CantFail match_fn) fail_expr +extractMatchResult (MatchResult CantFail match_fn) _ = match_fn (error "It can't fail!") -extractMatchResult (MatchResult CanFail match_fn) fail_expr - = mkFailurePair fail_expr `thenDs` \ (fail_bind, if_it_fails) -> - match_fn if_it_fails `thenDs` \ body -> - returnDs (mkDsLet fail_bind body) +extractMatchResult (MatchResult CanFail match_fn) fail_expr = do + (fail_bind, if_it_fails) <- mkFailurePair fail_expr + body <- match_fn if_it_fails + return (mkCoreLet fail_bind body) combineMatchResults :: MatchResult -> MatchResult -> MatchResult combineMatchResults (MatchResult CanFail body_fn1) - (MatchResult can_it_fail2 body_fn2) + (MatchResult can_it_fail2 body_fn2) = MatchResult can_it_fail2 body_fn where - body_fn fail = body_fn2 fail `thenDs` \ body2 -> - mkFailurePair body2 `thenDs` \ (fail_bind, duplicatable_expr) -> - body_fn1 duplicatable_expr `thenDs` \ body1 -> - returnDs (Let fail_bind body1) + body_fn fail = do body2 <- body_fn2 fail + (fail_bind, duplicatable_expr) <- mkFailurePair body2 + body1 <- body_fn1 duplicatable_expr + return (Let fail_bind body1) -combineMatchResults match_result1@(MatchResult CantFail body_fn1) match_result2 +combineMatchResults match_result1@(MatchResult CantFail _) _ = match_result1 adjustMatchResult :: DsWrapper -> MatchResult -> MatchResult adjustMatchResult encl_fn (MatchResult can_it_fail body_fn) - = MatchResult can_it_fail (\fail -> body_fn fail `thenDs` \ body -> - returnDs (encl_fn body)) + = MatchResult can_it_fail (\fail -> encl_fn <$> body_fn fail) adjustMatchResultDs :: (CoreExpr -> DsM CoreExpr) -> MatchResult -> MatchResult adjustMatchResultDs encl_fn (MatchResult can_it_fail body_fn) - = MatchResult can_it_fail (\fail -> body_fn fail `thenDs` \ body -> - encl_fn body) + = MatchResult can_it_fail (\fail -> encl_fn =<< body_fn fail) wrapBinds :: [(Var,Var)] -> CoreExpr -> CoreExpr wrapBinds [] e = e wrapBinds ((new,old):prs) e = wrapBind new old (wrapBinds prs e) wrapBind :: Var -> Var -> CoreExpr -> CoreExpr -wrapBind new old body +wrapBind new old body -- Can deal with term variables *or* type variables | new==old = body - | isTyVar new = App (Lam new body) (Type (mkTyVarTy old)) - | otherwise = Let (NonRec new (Var old)) body + | isTyCoVar new = Let (mkTyBind new (mkTyVarTy old)) body + | otherwise = Let (NonRec new (Var old)) body seqVar :: Var -> CoreExpr -> CoreExpr seqVar var body = Case (Var var) var (exprType body) [(DEFAULT, [], body)] mkCoLetMatchResult :: CoreBind -> MatchResult -> MatchResult -mkCoLetMatchResult bind = adjustMatchResult (mkDsLet bind) +mkCoLetMatchResult bind = adjustMatchResult (mkCoreLet bind) + +-- (mkViewMatchResult var' viewExpr var mr) makes the expression +-- let var' = viewExpr var in mr +mkViewMatchResult :: Id -> CoreExpr -> Id -> MatchResult -> MatchResult +mkViewMatchResult var' viewExpr var = + adjustMatchResult (mkCoreLet (NonRec var' (mkCoreAppDs viewExpr (Var var)))) mkEvalMatchResult :: Id -> Type -> MatchResult -> MatchResult mkEvalMatchResult var ty = adjustMatchResult (\e -> Case (Var var) var ty [(DEFAULT, [], e)]) mkGuardedMatchResult :: CoreExpr -> MatchResult -> MatchResult -mkGuardedMatchResult pred_expr (MatchResult can_it_fail body_fn) - = MatchResult CanFail (\fail -> body_fn fail `thenDs` \ body -> - returnDs (mkIfThenElse pred_expr body fail)) +mkGuardedMatchResult pred_expr (MatchResult _ body_fn) + = MatchResult CanFail (\fail -> do body <- body_fn fail + return (mkIfThenElse pred_expr body fail)) mkCoPrimCaseMatchResult :: Id -- Scrutinee -> Type -- Type of the case @@ -274,13 +290,13 @@ mkCoPrimCaseMatchResult :: Id -- Scrutinee mkCoPrimCaseMatchResult var ty match_alts = MatchResult CanFail mk_case where - mk_case fail - = mappM (mk_alt fail) sorted_alts `thenDs` \ alts -> - returnDs (Case (Var var) var ty ((DEFAULT, [], fail) : alts)) + mk_case fail = do + alts <- mapM (mk_alt fail) sorted_alts + return (Case (Var var) var ty ((DEFAULT, [], fail) : alts)) sorted_alts = sortWith fst match_alts -- Right order for a Case - mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body -> - returnDs (LitAlt lit, [], body) + mk_alt fail (lit, MatchResult _ body_fn) = do body <- body_fn fail + return (LitAlt lit, [], body) mkCoAlgCaseMatchResult :: Id -- Scrutinee @@ -303,10 +319,11 @@ mkCoAlgCaseMatchResult var ty match_alts -- the scrutinised Id to be sufficiently refined to have a TyCon in it] -- Stuff for newtype - (con1, arg_ids1, match_result1) = head match_alts - arg_id1 = head arg_ids1 + (con1, arg_ids1, match_result1) = ASSERT( notNull match_alts ) head match_alts + arg_id1 = ASSERT( notNull arg_ids1 ) head arg_ids1 var_ty = idType var - (tc, ty_args) = splitNewTyConApp var_ty + (tc, ty_args) = tcSplitTyConApp var_ty -- Don't look through newtypes + -- (not that splitTyConApp does, these days) newtype_rhs = unwrapNewTypeBody tc ty_args (Var var) -- Stuff for data types @@ -318,16 +335,15 @@ mkCoAlgCaseMatchResult var ty match_alts | otherwise = CanFail - wild_var = mkWildId (idType var) sorted_alts = sortWith get_tag match_alts get_tag (con, _, _) = dataConTag con - mk_case fail = mappM (mk_alt fail) sorted_alts `thenDs` \ alts -> - returnDs (Case (Var var) wild_var ty (mk_default fail ++ alts)) + mk_case fail = do alts <- mapM (mk_alt fail) sorted_alts + return (mkWildCase (Var var) (idType var) ty (mk_default fail ++ alts)) - mk_alt fail (con, args, MatchResult _ body_fn) - = body_fn fail `thenDs` \ body -> - newUniqueSupply `thenDs` \ us -> - returnDs (mkReboxingAlt (uniqsFromSupply us) con args body) + mk_alt fail (con, args, MatchResult _ body_fn) = do + body <- body_fn fail + us <- newUniqueSupply + return (mkReboxingAlt (uniqsFromSupply us) con args body) mk_default fail | exhaustive_case = [] | otherwise = [(DEFAULT, [], fail)] @@ -363,13 +379,13 @@ mkCoAlgCaseMatchResult var ty match_alts case (isPArrFakeCon dcon, isPArrFakeAlts alts) of (True , True ) -> True (False, False) -> False - _ -> - panic "DsUtils: You may not mix `[:...:]' with `PArr' patterns" + _ -> panic "DsUtils: you may not mix `[:...:]' with `PArr' patterns" + isPArrFakeAlts [] = panic "DsUtils: unexpectedly found an empty list of PArr fake alternatives" -- - mk_parrCase fail = - dsLookupGlobalId lengthPName `thenDs` \lengthP -> - unboxAlt `thenDs` \alt -> - returnDs (Case (len lengthP) (mkWildId intTy) ty [alt]) + mk_parrCase fail = do + lengthP <- dsLookupDPHId lengthPName + alt <- unboxAlt + return (mkWildCase (len lengthP) intTy ty [alt]) where elemTy = case splitTyConApp (idType var) of (_, [elemTy]) -> elemTy @@ -377,13 +393,12 @@ mkCoAlgCaseMatchResult var ty match_alts panicMsg = "DsUtils.mkCoAlgCaseMatchResult: not a parallel array?" len lengthP = mkApps (Var lengthP) [Type elemTy, Var var] -- - unboxAlt = - newSysLocalDs intPrimTy `thenDs` \l -> - dsLookupGlobalId indexPName `thenDs` \indexP -> - mappM (mkAlt indexP) sorted_alts `thenDs` \alts -> - returnDs (DataAlt intDataCon, [l], (Case (Var l) wild ty (dft : alts))) + unboxAlt = do + l <- newSysLocalDs intPrimTy + indexP <- dsLookupDPHId indexPName + alts <- mapM (mkAlt indexP) sorted_alts + return (DataAlt intDataCon, [l], mkWildCase (Var l) intPrimTy ty (dft : alts)) where - wild = mkWildId intPrimTy dft = (DEFAULT, [], fail) -- -- each alternative matches one array length (corresponding to one @@ -392,9 +407,9 @@ mkCoAlgCaseMatchResult var ty match_alts -- constructor argument, which are bound to array elements starting -- with the first -- - mkAlt indexP (con, args, MatchResult _ bodyFun) = - bodyFun fail `thenDs` \body -> - returnDs (LitAlt lit, [], mkDsLets binds body) + mkAlt indexP (con, args, MatchResult _ bodyFun) = do + body <- bodyFun fail + return (LitAlt lit, [], mkCoreLets binds body) where lit = MachInt $ toInteger (dataConSourceArity con) binds = [NonRec arg (indexExpr i) | (i, arg) <- zip [1..] args] @@ -402,7 +417,6 @@ mkCoAlgCaseMatchResult var ty match_alts indexExpr i = mkApps (Var indexP) [Type elemTy, Var var, mkIntExpr i] \end{code} - %************************************************************************ %* * \subsection{Desugarer's versions of some Core functions} @@ -412,92 +426,98 @@ mkCoAlgCaseMatchResult var ty match_alts \begin{code} mkErrorAppDs :: Id -- The error function -> Type -- Type to which it should be applied - -> String -- The error message string to pass + -> SDoc -- The error message string to pass -> DsM CoreExpr -mkErrorAppDs err_id ty msg - = getSrcSpanDs `thenDs` \ src_loc -> +mkErrorAppDs err_id ty msg = do + src_loc <- getSrcSpanDs let - full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg]) - core_msg = Lit (mkStringLit full_msg) - -- mkStringLit returns a result of type String# - in - returnDs (mkApps (Var err_id) [Type ty, core_msg]) + full_msg = showSDoc (hcat [ppr src_loc, text "|", msg]) + core_msg = Lit (mkMachString full_msg) + -- mkMachString returns a result of type String# + return (mkApps (Var err_id) [Type ty, core_msg]) \end{code} - -************************************************************* -%* * -\subsection{Making literals} -%* * -%************************************************************************ +'mkCoreAppDs' and 'mkCoreAppsDs' hand the special-case desugaring of 'seq'. + +Note [Desugaring seq (1)] cf Trac #1031 +~~~~~~~~~~~~~~~~~~~~~~~~~ + f x y = x `seq` (y `seq` (# x,y #)) + +The [CoreSyn let/app invariant] means that, other things being equal, because +the argument to the outer 'seq' has an unlifted type, we'll use call-by-value thus: + + f x y = case (y `seq` (# x,y #)) of v -> x `seq` v + +But that is bad for two reasons: + (a) we now evaluate y before x, and + (b) we can't bind v to an unboxed pair + +Seq is very, very special! So we recognise it right here, and desugar to + case x of _ -> case y of _ -> (# x,y #) + +Note [Desugaring seq (2)] cf Trac #2273 +~~~~~~~~~~~~~~~~~~~~~~~~~ +Consider + let chp = case b of { True -> fst x; False -> 0 } + in chp `seq` ...chp... +Here the seq is designed to plug the space leak of retaining (snd x) +for too long. + +If we rely on the ordinary inlining of seq, we'll get + let chp = case b of { True -> fst x; False -> 0 } + case chp of _ { I# -> ...chp... } + +But since chp is cheap, and the case is an alluring contet, we'll +inline chp into the case scrutinee. Now there is only one use of chp, +so we'll inline a second copy. Alas, we've now ruined the purpose of +the seq, by re-introducing the space leak: + case (case b of {True -> fst x; False -> 0}) of + I# _ -> ...case b of {True -> fst x; False -> 0}... + +We can try to avoid doing this by ensuring that the binder-swap in the +case happens, so we get his at an early stage: + case chp of chp2 { I# -> ...chp2... } +But this is fragile. The real culprit is the source program. Perhaps we +should have said explicitly + let !chp2 = chp in ...chp2... + +But that's painful. So the code here does a little hack to make seq +more robust: a saturated application of 'seq' is turned *directly* into +the case expression, thus: + x `seq` e2 ==> case x of x -> e2 -- Note shadowing! + e1 `seq` e2 ==> case x of _ -> e2 + +So we desugar our example to: + let chp = case b of { True -> fst x; False -> 0 } + case chp of chp { I# -> ...chp... } +And now all is well. + +The reason it's a hack is because if you define mySeq=seq, the hack +won't work on mySeq. + +Note [Desugaring seq (3)] cf Trac #2409 +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +The isLocalId ensures that we don't turn + True `seq` e +into + case True of True { ... } +which stupidly tries to bind the datacon 'True'. \begin{code} -mkCharExpr :: Char -> CoreExpr -- Returns C# c :: Int -mkIntExpr :: Integer -> CoreExpr -- Returns I# i :: Int -mkIntegerExpr :: Integer -> DsM CoreExpr -- Result :: Integer -mkStringExpr :: String -> DsM CoreExpr -- Result :: String -mkStringExprFS :: FastString -> DsM CoreExpr -- Result :: String - -mkIntExpr i = mkConApp intDataCon [mkIntLit i] -mkCharExpr c = mkConApp charDataCon [mkLit (MachChar c)] - -mkIntegerExpr i - | inIntRange i -- Small enough, so start from an Int - = dsLookupDataCon smallIntegerDataConName `thenDs` \ integer_dc -> - returnDs (mkSmallIntegerLit integer_dc i) - --- Special case for integral literals with a large magnitude: --- They are transformed into an expression involving only smaller --- integral literals. This improves constant folding. - - | otherwise -- Big, so start from a string - = dsLookupGlobalId plusIntegerName `thenDs` \ plus_id -> - dsLookupGlobalId timesIntegerName `thenDs` \ times_id -> - dsLookupDataCon smallIntegerDataConName `thenDs` \ integer_dc -> - let - lit i = mkSmallIntegerLit integer_dc i - plus a b = Var plus_id `App` a `App` b - times a b = Var times_id `App` a `App` b - - -- Transform i into (x1 + (x2 + (x3 + (...) * b) * b) * b) with abs xi <= b - horner :: Integer -> Integer -> CoreExpr - horner b i | abs q <= 1 = if r == 0 || r == i - then lit i - else lit r `plus` lit (i-r) - | r == 0 = horner b q `times` lit b - | otherwise = lit r `plus` (horner b q `times` lit b) - where - (q,r) = i `quotRem` b - - in - returnDs (horner tARGET_MAX_INT i) - -mkSmallIntegerLit small_integer_data_con i = mkConApp small_integer_data_con [mkIntLit i] - -mkStringExpr str = mkStringExprFS (mkFastString str) - -mkStringExprFS str - | nullFS str - = returnDs (mkNilExpr charTy) - - | lengthFS str == 1 - = let - the_char = mkCharExpr (headFS str) - in - returnDs (mkConsExpr charTy the_char (mkNilExpr charTy)) - - | all safeChar chars - = dsLookupGlobalId unpackCStringName `thenDs` \ unpack_id -> - returnDs (App (Var unpack_id) (Lit (MachStr str))) - - | otherwise - = dsLookupGlobalId unpackCStringUtf8Name `thenDs` \ unpack_id -> - returnDs (App (Var unpack_id) (Lit (MachStr str))) - +mkCoreAppDs :: CoreExpr -> CoreExpr -> CoreExpr +mkCoreAppDs (Var f `App` Type ty1 `App` Type ty2 `App` arg1) arg2 + | f `hasKey` seqIdKey -- Note [Desugaring seq (1), (2)] + = Case arg1 case_bndr ty2 [(DEFAULT,[],arg2)] where - chars = unpackFS str - safeChar c = ord c >= 1 && ord c <= 0x7F + case_bndr = case arg1 of + Var v1 | isLocalId v1 -> v1 -- Note [Desugaring seq (2) and (3)] + _ -> mkWildValBinder ty1 + +mkCoreAppDs fun arg = mkCoreApp fun arg -- The rest is done in MkCore + +mkCoreAppsDs :: CoreExpr -> [CoreExpr] -> CoreExpr +mkCoreAppsDs fun args = foldl mkCoreAppDs fun args \end{code} @@ -529,63 +549,60 @@ mkSelectorBinds :: LPat Id -- The pattern -> DsM [(Id,CoreExpr)] mkSelectorBinds (L _ (VarPat v)) val_expr - = returnDs [(v, val_expr)] + = return [(v, val_expr)] mkSelectorBinds pat val_expr - | isSingleton binders || is_simple_lpat pat - = -- Given p = e, where p binds x,y - -- we are going to make - -- v = p (where v is fresh) - -- x = case v of p -> x - -- y = case v of p -> x - - -- Make up 'v' - -- NB: give it the type of *pattern* p, not the type of the *rhs* e. - -- This does not matter after desugaring, but there's a subtle - -- issue with implicit parameters. Consider - -- (x,y) = ?i - -- Then, ?i is given type {?i :: Int}, a PredType, which is opaque - -- to the desugarer. (Why opaque? Because newtypes have to be. Why - -- does it get that type? So that when we abstract over it we get the - -- right top-level type (?i::Int) => ...) - -- - -- So to get the type of 'v', use the pattern not the rhs. Often more - -- efficient too. - newSysLocalDs (hsLPatType pat) `thenDs` \ val_var -> - - -- For the error message we make one error-app, to avoid duplication. - -- But we need it at different types... so we use coerce for that - mkErrorAppDs iRREFUT_PAT_ERROR_ID - unitTy (showSDoc (ppr pat)) `thenDs` \ err_expr -> - newSysLocalDs unitTy `thenDs` \ err_var -> - mappM (mk_bind val_var err_var) binders `thenDs` \ binds -> - returnDs ( (val_var, val_expr) : - (err_var, err_expr) : - binds ) - - - | otherwise - = mkErrorAppDs iRREFUT_PAT_ERROR_ID - tuple_ty (showSDoc (ppr pat)) `thenDs` \ error_expr -> - matchSimply val_expr PatBindRhs pat local_tuple error_expr `thenDs` \ tuple_expr -> - newSysLocalDs tuple_ty `thenDs` \ tuple_var -> - let - mk_tup_bind binder - = (binder, mkTupleSelector binders binder tuple_var (Var tuple_var)) - in - returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders ) + | isSingleton binders || is_simple_lpat pat = do + -- Given p = e, where p binds x,y + -- we are going to make + -- v = p (where v is fresh) + -- x = case v of p -> x + -- y = case v of p -> x + + -- Make up 'v' + -- NB: give it the type of *pattern* p, not the type of the *rhs* e. + -- This does not matter after desugaring, but there's a subtle + -- issue with implicit parameters. Consider + -- (x,y) = ?i + -- Then, ?i is given type {?i :: Int}, a PredType, which is opaque + -- to the desugarer. (Why opaque? Because newtypes have to be. Why + -- does it get that type? So that when we abstract over it we get the + -- right top-level type (?i::Int) => ...) + -- + -- So to get the type of 'v', use the pattern not the rhs. Often more + -- efficient too. + val_var <- newSysLocalDs (hsLPatType pat) + + -- For the error message we make one error-app, to avoid duplication. + -- But we need it at different types... so we use coerce for that + err_expr <- mkErrorAppDs iRREFUT_PAT_ERROR_ID unitTy (ppr pat) + err_var <- newSysLocalDs unitTy + binds <- mapM (mk_bind val_var err_var) binders + return ( (val_var, val_expr) : + (err_var, err_expr) : + binds ) + + + | otherwise = do + error_expr <- mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (ppr pat) + tuple_expr <- matchSimply val_expr PatBindRhs pat local_tuple error_expr + tuple_var <- newSysLocalDs tuple_ty + let mk_tup_bind binder + = (binder, mkTupleSelector local_binders binder tuple_var (Var tuple_var)) + return ( (tuple_var, tuple_expr) : map mk_tup_bind binders ) where - binders = collectPatBinders pat - local_tuple = mkTupleExpr binders - tuple_ty = exprType local_tuple + binders = collectPatBinders pat + local_binders = map localiseId binders -- See Note [Localise pattern binders] + local_tuple = mkBigCoreVarTup binders + tuple_ty = exprType local_tuple - mk_bind scrut_var err_var bndr_var + mk_bind scrut_var err_var bndr_var = do -- (mk_bind sv err_var) generates - -- bv = case sv of { pat -> bv; other -> coerce (type-of-bv) err_var } + -- bv = case sv of { pat -> bv; other -> coerce (type-of-bv) err_var } -- Remember, pat binds bv - = matchSimply (Var scrut_var) PatBindRhs pat - (Var bndr_var) error_expr `thenDs` \ rhs_expr -> - returnDs (bndr_var, rhs_expr) + rhs_expr <- matchSimply (Var scrut_var) PatBindRhs pat + (Var bndr_var) error_expr + return (bndr_var, rhs_expr) where error_expr = mkCoerce co (Var err_var) co = mkUnsafeCoercion (exprType (Var err_var)) (idType bndr_var) @@ -593,221 +610,54 @@ mkSelectorBinds pat val_expr is_simple_lpat p = is_simple_pat (unLoc p) is_simple_pat (TuplePat ps Boxed _) = all is_triv_lpat ps - is_simple_pat (ConPatOut{ pat_args = ps }) = all is_triv_lpat (hsConArgs ps) - is_simple_pat (VarPat _) = True - is_simple_pat (ParPat p) = is_simple_lpat p - is_simple_pat other = False + is_simple_pat (ConPatOut{ pat_args = ps }) = all is_triv_lpat (hsConPatArgs ps) + is_simple_pat (VarPat _) = True + is_simple_pat (ParPat p) = is_simple_lpat p + is_simple_pat _ = False is_triv_lpat p = is_triv_pat (unLoc p) - is_triv_pat (VarPat v) = True + is_triv_pat (VarPat _) = True is_triv_pat (WildPat _) = True is_triv_pat (ParPat p) = is_triv_lpat p - is_triv_pat other = False -\end{code} - - -%************************************************************************ -%* * - Tuples -%* * -%************************************************************************ - -@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. - -* If it has only one element, it is the identity function. - -* If there are more elements than a big tuple can have, it nests - the tuples. + is_triv_pat _ = False -Nesting policy. Better a 2-tuple of 10-tuples (3 objects) than -a 10-tuple of 2-tuples (11 objects). So we want the leaves to be big. - -\begin{code} -mkTupleExpr :: [Id] -> CoreExpr -mkTupleExpr ids = mkBigCoreTup (map Var ids) - --- corresponding type -mkTupleType :: [Id] -> Type -mkTupleType ids = mkBigTuple mkCoreTupTy (map idType ids) - -mkBigCoreTup :: [CoreExpr] -> CoreExpr -mkBigCoreTup = mkBigTuple mkCoreTup - -mkBigTuple :: ([a] -> a) -> [a] -> a -mkBigTuple small_tuple as = mk_big_tuple (chunkify as) - where - -- Each sub-list is short enough to fit in a tuple - mk_big_tuple [as] = small_tuple as - mk_big_tuple as_s = mk_big_tuple (chunkify (map small_tuple as_s)) - -chunkify :: [a] -> [[a]] --- The sub-lists of the result all have length <= mAX_TUPLE_SIZE --- But there may be more than mAX_TUPLE_SIZE sub-lists -chunkify xs - | n_xs <= mAX_TUPLE_SIZE = {- pprTrace "Small" (ppr n_xs) -} [xs] - | otherwise = {- pprTrace "Big" (ppr n_xs) -} (split xs) - where - n_xs = length xs - split [] = [] - split xs = take mAX_TUPLE_SIZE xs : split (drop mAX_TUPLE_SIZE xs) \end{code} - -@mkTupleSelector@ builds a selector which scrutises the given -expression and extracts the one name from the list given. -If you want the no-shadowing rule to apply, the caller -is responsible for making sure that none of these names -are in scope. - -If there is just one id in the ``tuple'', then the selector is -just the identity. - -If it's big, it does nesting - mkTupleSelector [a,b,c,d] b v e - = case e of v { - (p,q) -> case p of p { - (a,b) -> b }} -We use 'tpl' vars for the p,q, since shadowing does not matter. - -In fact, it's more convenient to generate it innermost first, getting - - case (case e of v - (p,q) -> p) of p - (a,b) -> b +Creating big tuples and their types for full Haskell expressions. +They work over *Ids*, and create tuples replete with their types, +which is whey they are not in HsUtils. \begin{code} -mkTupleSelector :: [Id] -- The tuple args - -> Id -- The selected one - -> Id -- A variable of the same type as the scrutinee - -> CoreExpr -- Scrutinee - -> CoreExpr - -mkTupleSelector vars the_var scrut_var scrut - = mk_tup_sel (chunkify vars) the_var - where - mk_tup_sel [vars] the_var = mkCoreSel vars the_var scrut_var scrut - mk_tup_sel vars_s the_var = mkCoreSel group the_var tpl_v $ - mk_tup_sel (chunkify tpl_vs) tpl_v - where - tpl_tys = [mkCoreTupTy (map idType gp) | gp <- vars_s] - tpl_vs = mkTemplateLocals tpl_tys - [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s, - the_var `elem` gp ] -\end{code} - -A generalization of @mkTupleSelector@, allowing the body -of the case to be an arbitrary expression. - -If the tuple is big, it is nested: - - mkTupleCase uniqs [a,b,c,d] body v e - = case e of v { (p,q) -> - case p of p { (a,b) -> - case q of q { (c,d) -> - body }}} - -To avoid shadowing, we use uniqs to invent new variables p,q. - -ToDo: eliminate cases where none of the variables are needed. +mkLHsPatTup :: [LPat Id] -> LPat Id +mkLHsPatTup [] = noLoc $ mkVanillaTuplePat [] Boxed +mkLHsPatTup [lpat] = lpat +mkLHsPatTup lpats = L (getLoc (head lpats)) $ + mkVanillaTuplePat lpats Boxed -\begin{code} -mkTupleCase - :: UniqSupply -- for inventing names of intermediate variables - -> [Id] -- the tuple args - -> CoreExpr -- body of the case - -> Id -- a variable of the same type as the scrutinee - -> CoreExpr -- scrutinee - -> CoreExpr - -mkTupleCase uniqs vars body scrut_var scrut - = mk_tuple_case uniqs (chunkify vars) body - where - mk_tuple_case us [vars] body - = mkSmallTupleCase vars body scrut_var scrut - mk_tuple_case us vars_s body - = let - (us', vars', body') = foldr one_tuple_case (us, [], body) vars_s - in - mk_tuple_case us' (chunkify vars') body' - one_tuple_case chunk_vars (us, vs, body) - = let - (us1, us2) = splitUniqSupply us - scrut_var = mkSysLocal FSLIT("ds") (uniqFromSupply us1) - (mkCoreTupTy (map idType chunk_vars)) - body' = mkSmallTupleCase chunk_vars body scrut_var (Var scrut_var) - in (us2, scrut_var:vs, body') -\end{code} +mkLHsVarPatTup :: [Id] -> LPat Id +mkLHsVarPatTup bs = mkLHsPatTup (map nlVarPat bs) -The same, but with a tuple small enough not to need nesting. +mkVanillaTuplePat :: [OutPat Id] -> Boxity -> Pat Id +-- A vanilla tuple pattern simply gets its type from its sub-patterns +mkVanillaTuplePat pats box + = TuplePat pats box (mkTupleTy box (map hsLPatType pats)) -\begin{code} -mkSmallTupleCase - :: [Id] -- the tuple args - -> CoreExpr -- body of the case - -> Id -- a variable of the same type as the scrutinee - -> CoreExpr -- scrutinee - -> CoreExpr - -mkSmallTupleCase [var] body _scrut_var scrut - = bindNonRec var scrut body -mkSmallTupleCase vars body scrut_var scrut --- One branch no refinement? - = Case scrut scrut_var (exprType body) [(DataAlt (tupleCon Boxed (length vars)), vars, body)] -\end{code} +-- The Big equivalents for the source tuple expressions +mkBigLHsVarTup :: [Id] -> LHsExpr Id +mkBigLHsVarTup ids = mkBigLHsTup (map nlHsVar ids) -%************************************************************************ -%* * -\subsection[mkFailurePair]{Code for pattern-matching and other failures} -%* * -%************************************************************************ +mkBigLHsTup :: [LHsExpr Id] -> LHsExpr Id +mkBigLHsTup = mkChunkified mkLHsTupleExpr -Call the constructor Ids when building explicit lists, so that they -interact well with rules. +-- The Big equivalents for the source tuple patterns +mkBigLHsVarPatTup :: [Id] -> LPat Id +mkBigLHsVarPatTup bs = mkBigLHsPatTup (map nlVarPat bs) -\begin{code} -mkNilExpr :: Type -> CoreExpr -mkNilExpr ty = mkConApp nilDataCon [Type ty] - -mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr -mkConsExpr ty hd tl = mkConApp consDataCon [Type ty, hd, tl] - -mkListExpr :: Type -> [CoreExpr] -> CoreExpr -mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs - - --- The next three functions make tuple types, constructors and selectors, --- with the rule that a 1-tuple is represented by the thing itselg -mkCoreTupTy :: [Type] -> Type -mkCoreTupTy [ty] = ty -mkCoreTupTy tys = mkTupleTy Boxed (length tys) tys - -mkCoreTup :: [CoreExpr] -> CoreExpr --- Builds exactly the specified tuple. --- No fancy business for big tuples -mkCoreTup [] = Var unitDataConId -mkCoreTup [c] = c -mkCoreTup cs = mkConApp (tupleCon Boxed (length cs)) - (map (Type . exprType) cs ++ cs) - -mkCoreSel :: [Id] -- The tuple args - -> Id -- The selected one - -> Id -- A variable of the same type as the scrutinee - -> CoreExpr -- Scrutinee - -> CoreExpr --- mkCoreSel [x,y,z] x v e --- ===> case e of v { (x,y,z) -> x -mkCoreSel [var] should_be_the_same_var scrut_var scrut - = ASSERT(var == should_be_the_same_var) - scrut - -mkCoreSel vars the_var scrut_var scrut - = ASSERT( notNull vars ) - Case scrut scrut_var (idType the_var) - [(DataAlt (tupleCon Boxed (length vars)), vars, Var the_var)] +mkBigLHsPatTup :: [LPat Id] -> LPat Id +mkBigLHsPatTup = mkChunkified mkLHsPatTup \end{code} - %************************************************************************ %* * \subsection[mkFailurePair]{Code for pattern-matching and other failures} @@ -865,51 +715,71 @@ Now @fail.33@ is a function, so it can be let-bound. \begin{code} mkFailurePair :: CoreExpr -- Result type of the whole case expression -> DsM (CoreBind, -- Binds the newly-created fail variable - -- to either the expression or \ _ -> expression - CoreExpr) -- Either the fail variable, or fail variable - -- applied to unit tuple + -- to \ _ -> expression + CoreExpr) -- Fail variable applied to realWorld# +-- See Note [Failure thunks and CPR] mkFailurePair expr - | isUnLiftedType ty - = newFailLocalDs (unitTy `mkFunTy` ty) `thenDs` \ fail_fun_var -> - newSysLocalDs unitTy `thenDs` \ fail_fun_arg -> - returnDs (NonRec fail_fun_var (Lam fail_fun_arg expr), - App (Var fail_fun_var) (Var unitDataConId)) - - | otherwise - = newFailLocalDs ty `thenDs` \ fail_var -> - returnDs (NonRec fail_var expr, Var fail_var) + = do { fail_fun_var <- newFailLocalDs (realWorldStatePrimTy `mkFunTy` ty) + ; fail_fun_arg <- newSysLocalDs realWorldStatePrimTy + ; return (NonRec fail_fun_var (Lam fail_fun_arg expr), + App (Var fail_fun_var) (Var realWorldPrimId)) } where ty = exprType expr \end{code} +Note [Failure thunks and CPR] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +When we make a failure point we ensure that it +does not look like a thunk. Example: + + let fail = \rw -> error "urk" + in case x of + [] -> fail realWorld# + (y:ys) -> case ys of + [] -> fail realWorld# + (z:zs) -> (y,z) + +Reason: we know that a failure point is always a "join point" and is +entered at most once. Adding a dummy 'realWorld' token argument makes +it clear that sharing is not an issue. And that in turn makes it more +CPR-friendly. This matters a lot: if you don't get it right, you lose +the tail call property. For example, see Trac #3403. + \begin{code} -mkOptTickBox :: Maybe Int -> CoreExpr -> DsM CoreExpr +mkOptTickBox :: Maybe (Int,[Id]) -> CoreExpr -> DsM CoreExpr mkOptTickBox Nothing e = return e -mkOptTickBox (Just ix) e = mkTickBox ix e +mkOptTickBox (Just (ix,ids)) e = mkTickBox ix ids e -mkTickBox :: Int -> CoreExpr -> DsM CoreExpr -mkTickBox ix e = do - dflags <- getDOptsDs +mkTickBox :: Int -> [Id] -> CoreExpr -> DsM CoreExpr +mkTickBox ix vars e = do uq <- newUnique mod <- getModuleDs - let tick = mkTickBoxOpId uq mod ix + let tick | opt_Hpc = mkTickBoxOpId uq mod ix + | otherwise = mkBreakPointOpId uq mod ix uq2 <- newUnique let occName = mkVarOcc "tick" - let name = mkInternalName uq2 occName noSrcLoc -- use mkSysLocal? + let name = mkInternalName uq2 occName noSrcSpan -- use mkSysLocal? let var = Id.mkLocalId name realWorldStatePrimTy - return $ Case (Var tick) - var - ty - [(DEFAULT,[],e)] + scrut <- + if opt_Hpc + then return (Var tick) + else do + let tickVar = Var tick + let tickType = mkFunTys (map idType vars) realWorldStatePrimTy + let scrutApTy = App tickVar (Type tickType) + return (mkApps scrutApTy (map Var vars) :: Expr Id) + return $ Case scrut var ty [(DEFAULT,[],e)] where ty = exprType e mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr mkBinaryTickBox ixT ixF e = do - mod <- getModuleDs - dflags <- getDOptsDs uq <- newUnique - mod <- getModuleDs - let tick = mkBinaryTickBoxOpId uq mod ixT ixF - return $ App (Var tick) e -\end{code} \ No newline at end of file + let bndr1 = mkSysLocal (fsLit "t1") uq boolTy + falseBox <- mkTickBox ixF [] $ Var falseDataConId + trueBox <- mkTickBox ixT [] $ Var trueDataConId + return $ Case e bndr1 boolTy + [ (DataAlt falseDataCon, [], falseBox) + , (DataAlt trueDataCon, [], trueBox) + ] +\end{code}