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, mkDsApp, mkDsApps,
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
import HsSyn
import TcHsSyn
+import TcType( tcSplitTyConApp )
import CoreSyn
-import Constants
import DsMonad
import CoreUtils
+import MkCore
import MkId
import Id
import Var
import ListSetOps
import FastString
import StaticFlags
-
-import Data.Char
-
-infixl 4 `mkDsApp`, `mkDsApps`
\end{code}
-> 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 -- See Note [CoreSyn let/app invariant]
- | isUnLiftedType (idType bndr) && not (exprOkForSpeculation rhs)
- = Case rhs bndr (exprType body) [(DEFAULT,[],body)]
-mkDsLet bind body
- = Let bind body
-
-mkDsLets :: [CoreBind] -> CoreExpr -> CoreExpr
-mkDsLets binds body = foldr mkDsLet body binds
-
------------
-mkDsApp :: CoreExpr -> CoreExpr -> CoreExpr
--- Check the invariant that the arg of an App is ok-for-speculation if unlifted
--- See CoreSyn Note [CoreSyn let/app invariant]
-mkDsApp fun (Type ty) = App fun (Type ty)
-mkDsApp fun arg = mk_val_app fun arg arg_ty res_ty
- where
- (arg_ty, res_ty) = splitFunTy (exprType fun)
-
------------
-mkDsApps :: CoreExpr -> [CoreExpr] -> CoreExpr
--- Slightly more efficient version of (foldl mkDsApp)
-mkDsApps fun args
- = go fun (exprType fun) args
- where
- go fun fun_ty [] = fun
- go fun fun_ty (Type ty : args) = go (App fun (Type ty)) (applyTy fun_ty ty) args
- go fun fun_ty (arg : args) = go (mk_val_app fun arg arg_ty res_ty) res_ty args
- where
- (arg_ty, res_ty) = splitFunTy fun_ty
------------
-mk_val_app fun arg arg_ty res_ty -- See Note [CoreSyn let/app invariant]
- | not (isUnLiftedType arg_ty) || exprOkForSpeculation arg
- = App fun arg -- The vastly common case
-
-mk_val_app (Var f `App` Type ty1 `App` Type ty2 `App` arg1) arg2 _ res_ty
- | f == seqId -- Note [Desugaring seq]
- = Case arg1 (mkWildId ty1) res_ty [(DEFAULT,[],arg2)]
-
-mk_val_app fun arg arg_ty res_ty
- = Case arg (mkWildId arg_ty) res_ty [(DEFAULT,[],App fun (Var arg_id))]
- where
- arg_id = mkWildId arg_ty -- Lots of shadowing, but it doesn't matter,
- -- because 'fun ' should not have a free wild-id
-\end{code}
-
-Note [Desugaring seq] 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 #)
-
-The special case would be valid for all calls to 'seq', but it's only *necessary*
-for ones whose second argument has an unlifted type. So we only catch the latter
-case here, to avoid unnecessary tests.
-
-
%************************************************************************
%* *
\subsection{ Selecting match variables}
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 var
+selectMatchVar (AsPat var _) = return (unLoc var)
+selectMatchVar other_pat = newSysLocalDs (hsPatType other_pat)
-- OK, better make up one...
\end{code}
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
+ | isTyVar 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
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
(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
| 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)]
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 <- dsLookupGlobalId lengthPName
+ alt <- unboxAlt
+ return (mkWildCase (len lengthP) intTy ty [alt])
where
elemTy = case splitTyConApp (idType var) of
(_, [elemTy]) -> elemTy
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 <- dsLookupGlobalId 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
-- 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]
indexExpr i = mkApps (Var indexP) [Type elemTy, Var var, mkIntExpr i]
\end{code}
-
%************************************************************************
%* *
\subsection{Desugarer's versions of some Core functions}
\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}
+'mkCoreAppDs' and 'mkCoreAppsDs' hand the special-case desugaring of 'seq'.
-*************************************************************
-%* *
-\subsection{Making literals}
-%* *
-%************************************************************************
+Note [Desugaring seq (1)] cf Trac #1031
+~~~~~~~~~~~~~~~~~~~~~~~~~
+ f x y = x `seq` (y `seq` (# x,y #))
-\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)))
+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}
+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)]
+ _ -> mkWildBinder 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}
-> 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 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
+ binders = collectPatBinders pat
+ 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)
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.
+ is_triv_pat _ = False
-* If there are more elements than a big tuple can have, it nests
- the tuples.
-
-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}
+mkLHsPatTup :: [LPat Id] -> LPat Id
+mkLHsPatTup [] = noLoc $ mkVanillaTuplePat [] Boxed
+mkLHsPatTup [lpat] = lpat
+mkLHsPatTup lpats = L (getLoc (head lpats)) $
+ mkVanillaTuplePat lpats Boxed
-A generalization of @mkTupleSelector@, allowing the body
-of the case to be an arbitrary expression.
+mkLHsVarPatTup :: [Id] -> LPat Id
+mkLHsVarPatTup bs = mkLHsPatTup (map nlVarPat bs)
-If the tuple is big, it is nested:
+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))
- 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 }}}
+-- The Big equivalents for the source tuple expressions
+mkBigLHsVarTup :: [Id] -> LHsExpr Id
+mkBigLHsVarTup ids = mkBigLHsTup (map nlHsVar ids)
-To avoid shadowing, we use uniqs to invent new variables p,q.
+mkBigLHsTup :: [LHsExpr Id] -> LHsExpr Id
+mkBigLHsTup = mkChunkified mkLHsTupleExpr
-ToDo: eliminate cases where none of the variables are needed.
+-- The Big equivalents for the source tuple patterns
+mkBigLHsVarPatTup :: [Id] -> LPat Id
+mkBigLHsVarPatTup bs = mkBigLHsPatTup (map nlVarPat bs)
-\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}
-
-The same, but with a tuple small enough not to need nesting.
-
-\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}
-
-%************************************************************************
-%* *
-\subsection[mkFailurePair]{Code for pattern-matching and other failures}
-%* *
-%************************************************************************
-
-Call the constructor Ids when building explicit lists, so that they
-interact well with rules.
-
-\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}
%************************************************************************
\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,[Id]) -> CoreExpr -> DsM CoreExpr
mkOptTickBox Nothing e = return e
| 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
scrut <-
if opt_Hpc
mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr
mkBinaryTickBox ixT ixF e = do
- mod <- getModuleDs
uq <- newUnique
- mod <- getModuleDs
- let bndr1 = mkSysLocal FSLIT("t1") uq boolTy
+ let bndr1 = mkSysLocal (fsLit "t1") uq boolTy
falseBox <- mkTickBox ixF [] $ Var falseDataConId
trueBox <- mkTickBox ixT [] $ Var trueDataConId
return $ Case e bndr1 boolTy