%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[DsUtils]{Utilities for desugaring}
This module exports some utility functions of no great interest.
\begin{code}
-#include "HsVersions.h"
-
module DsUtils (
- CanItFail(..), EquationInfo(..), MatchResult(..),
-
- combineGRHSMatchResults,
- combineMatchResults,
- dsExprToAtom, SYN_IE(DsCoreArg),
- mkCoAlgCaseMatchResult,
- mkAppDs, mkConDs, mkPrimDs, mkErrorAppDs,
- mkCoLetsMatchResult,
- mkCoPrimCaseMatchResult,
- mkFailurePair,
- mkGuardedMatchResult,
- mkSelectorBinds,
- mkTupleBind,
- mkTupleExpr,
- selectMatchVars,
- showForErr
+ EquationInfo(..),
+ firstPat, shiftEqns,
+
+ mkDsLet, mkDsLets,
+
+ MatchResult(..), CanItFail(..),
+ cantFailMatchResult, alwaysFailMatchResult,
+ extractMatchResult, combineMatchResults,
+ adjustMatchResult, adjustMatchResultDs,
+ mkCoLetMatchResult,
+ mkGuardedMatchResult,
+ mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult,
+ wrapBind, wrapBinds,
+
+ mkErrorAppDs, mkNilExpr, mkConsExpr, mkListExpr,
+ mkIntExpr, mkCharExpr,
+ mkStringExpr, mkStringExprFS, mkIntegerExpr,
+
+ mkSelectorBinds, mkTupleExpr, mkTupleSelector,
+ mkTupleType, mkTupleCase, mkBigCoreTup,
+ mkCoreTup, mkCoreTupTy,
+
+ dsReboundNames, lookupReboundName,
+
+ selectSimpleMatchVarL, selectMatchVars
) where
-IMP_Ubiq()
-IMPORT_DELOOPER(DsLoop) ( match, matchSimply )
+#include "HsVersions.h"
-import HsSyn ( HsExpr(..), OutPat(..), HsLit(..),
- Match, HsBinds, Stmt, Qualifier, PolyType, ArithSeqInfo )
-import TcHsSyn ( SYN_IE(TypecheckedPat) )
-import DsHsSyn ( outPatType )
-import CoreSyn
+import {-# SOURCE #-} Match ( matchSimply )
+import {-# SOURCE #-} DsExpr( dsExpr )
+import HsSyn
+import TcHsSyn ( hsPatType )
+import CoreSyn
+import Constants ( mAX_TUPLE_SIZE )
import DsMonad
-import CoreUtils ( coreExprType, mkCoreIfThenElse )
-import PprStyle ( PprStyle(..) )
-import PrelVals ( iRREFUT_PAT_ERROR_ID, voidId )
-import Pretty ( ppShow )
-import Id ( idType, dataConArgTys, mkTupleCon,
--- pprId{-ToDo:rm-},
- SYN_IE(DataCon), SYN_IE(DictVar), SYN_IE(Id), GenId )
-import Literal ( Literal(..) )
-import TyCon ( mkTupleTyCon, isNewTyCon, tyConDataCons )
-import Type ( mkTyVarTys, mkRhoTy, mkForAllTys, mkFunTy,
- mkTheta, isUnboxedType, applyTyCon, getAppTyCon
- )
-import TysPrim ( voidTy )
-import UniqSet ( mkUniqSet, minusUniqSet, uniqSetToList, SYN_IE(UniqSet) )
-import Util ( panic, assertPanic{-, pprTrace ToDo:rm-} )
-import Usage ( SYN_IE(UVar) )
---import PprCore{-ToDo:rm-}
---import PprType--ToDo:rm
---import Pretty--ToDo:rm
---import TyVar--ToDo:rm
---import Unique--ToDo:rm
+import CoreUtils ( exprType, mkIfThenElse, mkCoerce, bindNonRec )
+import MkId ( iRREFUT_PAT_ERROR_ID, mkReboxingAlt, mkNewTypeBody )
+import Id ( idType, Id, mkWildId, mkTemplateLocals, mkSysLocal )
+import Var ( Var )
+import Name ( Name )
+import Literal ( Literal(..), mkStringLit, inIntRange, tARGET_MAX_INT )
+import TyCon ( isNewTyCon, tyConDataCons )
+import DataCon ( DataCon, dataConSourceArity, dataConTyCon, dataConTag )
+import Type ( mkFunTy, isUnLiftedType, Type, splitTyConApp, mkTyVarTy )
+import TcType ( tcEqType )
+import TysPrim ( intPrimTy )
+import TysWiredIn ( nilDataCon, consDataCon,
+ tupleCon, mkTupleTy,
+ unitDataConId, unitTy,
+ charTy, charDataCon,
+ intTy, intDataCon,
+ isPArrFakeCon )
+import BasicTypes ( Boxity(..) )
+import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet )
+import UniqSupply ( splitUniqSupply, uniqFromSupply, uniqsFromSupply )
+import PrelNames ( unpackCStringName, unpackCStringUtf8Name,
+ plusIntegerName, timesIntegerName, smallIntegerDataConName,
+ lengthPName, indexPName )
+import Outputable
+import UnicodeUtil ( intsToUtf8 )
+import SrcLoc ( Located(..), unLoc )
+import Util ( isSingleton, notNull, zipEqual, sortWith )
+import ListSetOps ( assocDefault )
+import FastString
+\end{code}
+
+
+
+%************************************************************************
+%* *
+ Rebindable syntax
+%* *
+%************************************************************************
+
+\begin{code}
+dsReboundNames :: ReboundNames Id
+ -> DsM ([CoreBind], -- Auxiliary bindings
+ [(Name,Id)]) -- Maps the standard name to its value
+
+dsReboundNames rebound_ids
+ = mapAndUnzipDs mk_bind rebound_ids `thenDs` \ (binds_s, prs) ->
+ return (concat binds_s, prs)
+ where
+ -- 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))
+
+lookupReboundName :: [(Name,Id)] -> Name -> CoreExpr
+lookupReboundName prs std_name
+ = Var (assocDefault (mk_panic std_name) prs std_name)
+ where
+ mk_panic std_name = pprPanic "dsReboundNames" (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}
+%* *
+%************************************************************************
+
+We're about to match against some patterns. We want to make some
+@Ids@ to use as match variables. If a pattern has an @Id@ readily at
+hand, which should indeed be bound to the pattern as a whole, then use it;
+otherwise, make one up.
+
+\begin{code}
+selectSimpleMatchVarL :: LPat Id -> DsM Id
+selectSimpleMatchVarL pat = selectMatchVar (unLoc pat) (hsPatType pat)
+
+-- (selectMatchVars ps tys) chooses variables of type tys
+-- to use for matching ps against. If the pattern is a variable,
+-- we try to use that, to save inventing lots of fresh variables.
+-- But even if it is a variable, its type might not match. Consider
+-- data T a where
+-- T1 :: Int -> T Int
+-- T2 :: a -> T a
+--
+-- f :: T a -> a -> Int
+-- f (T1 i) (x::Int) = x
+-- f (T2 i) (y::a) = 0
+-- Then we must not choose (x::Int) as the matching variable!
+
+selectMatchVars :: [Pat Id] -> [Type] -> DsM [Id]
+selectMatchVars [] [] = return []
+selectMatchVars (p:ps) (ty:tys) = do { v <- selectMatchVar p ty
+ ; vs <- selectMatchVars ps tys
+ ; return (v:vs) }
+
+selectMatchVar (LazyPat pat) pat_ty = selectMatchVar (unLoc pat) pat_ty
+selectMatchVar (VarPat var) pat_ty = try_for var pat_ty
+selectMatchVar (AsPat var pat) pat_ty = try_for (unLoc var) pat_ty
+selectMatchVar other_pat pat_ty = newSysLocalDs pat_ty -- OK, better make up one...
+
+try_for var pat_ty
+ | idType var `tcEqType` pat_ty = returnDs var
+ | otherwise = newSysLocalDs pat_ty
\end{code}
+
%************************************************************************
%* *
%* type synonym EquationInfo and access functions for its pieces *
worthy of a type synonym and a few handy functions.
\begin{code}
-data EquationInfo
- = EqnInfo
- [TypecheckedPat] -- the patterns for an eqn
- MatchResult -- Encapsulates the guards and bindings
-\end{code}
-
-\begin{code}
-data MatchResult
- = MatchResult
- CanItFail
- Type -- Type of argument expression
+firstPat :: EquationInfo -> Pat Id
+firstPat eqn = head (eqn_pats eqn)
- (CoreExpr -> CoreExpr)
- -- Takes a expression to plug in at the
- -- failure point(s). The expression should
- -- be duplicatable!
+shiftEqns :: [EquationInfo] -> [EquationInfo]
+-- Drop the first pattern in each equation
+shiftEqns eqns = [ eqn { eqn_pats = tail (eqn_pats eqn) } | eqn <- eqns ]
+\end{code}
- DsMatchContext -- The context info is used when producing warnings
- -- about shadowed patterns. It's the context
- -- of the *first* thing matched in this group.
- -- Should perhaps be a list of them all!
+Functions on MatchResults
-data CanItFail = CanFail | CantFail
+\begin{code}
+alwaysFailMatchResult :: MatchResult
+alwaysFailMatchResult = MatchResult CanFail (\fail -> returnDs fail)
-orFail CantFail CantFail = CantFail
-orFail _ _ = CanFail
+cantFailMatchResult :: CoreExpr -> MatchResult
+cantFailMatchResult expr = MatchResult CantFail (\ ignore -> returnDs expr)
+extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr
+extractMatchResult (MatchResult CantFail match_fn) fail_expr
+ = match_fn (error "It can't fail!")
-mkCoLetsMatchResult :: [CoreBinding] -> MatchResult -> MatchResult
-mkCoLetsMatchResult binds (MatchResult can_it_fail ty body_fn cxt)
- = MatchResult can_it_fail ty (\body -> mkCoLetsAny binds (body_fn body)) cxt
+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)
-mkGuardedMatchResult :: CoreExpr -> MatchResult -> DsM MatchResult
-mkGuardedMatchResult pred_expr (MatchResult can_it_fail ty body_fn cxt)
- = returnDs (MatchResult CanFail
- ty
- (\fail -> mkCoreIfThenElse pred_expr (body_fn fail) fail)
- cxt
- )
-mkCoPrimCaseMatchResult :: Id -- Scrutinee
- -> [(Literal, MatchResult)] -- Alternatives
- -> DsM MatchResult
-mkCoPrimCaseMatchResult var alts
- = newSysLocalDs (idType var) `thenDs` \ wild ->
- returnDs (MatchResult CanFail
- ty1
- (mk_case alts wild)
- cxt1)
+combineMatchResults :: MatchResult -> MatchResult -> MatchResult
+combineMatchResults (MatchResult CanFail body_fn1)
+ (MatchResult can_it_fail2 body_fn2)
+ = MatchResult can_it_fail2 body_fn
where
- ((_,MatchResult _ ty1 _ cxt1) : _) = alts
+ 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)
+
+combineMatchResults match_result1@(MatchResult CantFail body_fn1) match_result2
+ = match_result1
+
+adjustMatchResult :: (CoreExpr -> CoreExpr) -> 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))
+
+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)
+
+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
+ | new==old = body
+ | isTyVar new = App (Lam new body) (Type (mkTyVarTy old))
+ | otherwise = Let (NonRec new (Var old)) body
+
+mkCoLetMatchResult :: CoreBind -> MatchResult -> MatchResult
+mkCoLetMatchResult bind match_result
+ = adjustMatchResult (mkDsLet bind) match_result
+
+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))
- mk_case alts wild fail_expr
- = Case (Var var) (PrimAlts final_alts (BindDefault wild fail_expr))
- where
- final_alts = [ (lit, body_fn fail_expr)
- | (lit, MatchResult _ _ body_fn _) <- alts
- ]
-
-
-mkCoAlgCaseMatchResult :: Id -- Scrutinee
- -> [(DataCon, [Id], MatchResult)] -- Alternatives
- -> DsM MatchResult
-
-mkCoAlgCaseMatchResult var alts
- | isNewTyCon tycon -- newtype case; use a let
- = ASSERT( newtype_sanity )
- returnDs (mkCoLetsMatchResult [coercion_bind] match_result)
-
- | otherwise -- datatype case
- = -- Find all the constructors in the type which aren't
- -- explicitly mentioned in the alternatives:
- case un_mentioned_constructors of
- [] -> -- All constructors mentioned, so no default needed
- returnDs (MatchResult can_any_alt_fail
- ty1
- (mk_case alts (\ignore -> NoDefault))
- cxt1)
-
- [con] -> -- Just one constructor missing, so add a case for it
- -- We need to build new locals for the args of the constructor,
- -- and figuring out their types is somewhat tiresome.
- let
- arg_tys = dataConArgTys con tycon_arg_tys
- in
- newSysLocalsDs arg_tys `thenDs` \ arg_ids ->
-
- -- Now we are ready to construct the new alternative
- let
- new_alt = (con, arg_ids, MatchResult CanFail ty1 id NoMatchContext)
- in
- returnDs (MatchResult CanFail
- ty1
- (mk_case (new_alt:alts) (\ignore -> NoDefault))
- cxt1)
-
- other -> -- Many constructors missing, so use a default case
- newSysLocalDs scrut_ty `thenDs` \ wild ->
- returnDs (MatchResult CanFail
- ty1
- (mk_case alts (\fail_expr -> BindDefault wild fail_expr))
- cxt1)
+mkCoPrimCaseMatchResult :: Id -- Scrutinee
+ -> Type -- Type of the case
+ -> [(Literal, MatchResult)] -- Alternatives
+ -> MatchResult
+mkCoPrimCaseMatchResult var ty match_alts
+ = MatchResult CanFail mk_case
where
- -- Common stuff
- scrut_ty = idType var
- (tycon, tycon_arg_tys) = --pprTrace "CoAlgCase:" (pprType PprDebug scrut_ty) $
- getAppTyCon scrut_ty
+ mk_case fail
+ = mappM (mk_alt fail) sorted_alts `thenDs` \ alts ->
+ returnDs (Case (Var var) var ty ((DEFAULT, [], fail) : alts))
- -- Stuff for newtype
- (con_id, arg_ids, match_result) = head alts
- arg_id = head arg_ids
- coercion_bind = NonRec arg_id (Coerce (CoerceOut con_id)
- (idType arg_id)
- (Var var))
- newtype_sanity = null (tail alts) && null (tail arg_ids)
+ 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)
- -- Stuff for data types
- data_cons = tyConDataCons tycon
- un_mentioned_constructors
- = uniqSetToList (mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- alts] )
+mkCoAlgCaseMatchResult :: Id -- Scrutinee
+ -> Type -- Type of exp
+ -> [(DataCon, [CoreBndr], MatchResult)] -- Alternatives
+ -> MatchResult
+mkCoAlgCaseMatchResult var ty match_alts
+ | isNewTyCon tycon -- Newtype case; use a let
+ = ASSERT( null (tail match_alts) && null (tail arg_ids1) )
+ mkCoLetMatchResult (NonRec arg_id1 newtype_rhs) match_result1
- match_results = [match_result | (_,_,match_result) <- alts]
- (MatchResult _ ty1 _ cxt1 : _) = match_results
- can_any_alt_fail = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ _ _ <- match_results]
+ | isPArrFakeAlts match_alts -- Sugared parallel array; use a literal case
+ = MatchResult CanFail mk_parrCase
- mk_case alts deflt_fn fail_expr
- = Case (Var var) (AlgAlts final_alts (deflt_fn fail_expr))
- where
- final_alts = [ (con, args, body_fn fail_expr)
- | (con, args, MatchResult _ _ body_fn _) <- alts
- ]
+ | otherwise -- Datatype case; use a case
+ = MatchResult fail_flag mk_case
+ where
+ tycon = dataConTyCon con1
+ -- [Interesting: becuase of GADTs, we can't rely on the type of
+ -- 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
+ newtype_rhs = mkNewTypeBody tycon (idType arg_id1) (Var var)
+
+ -- Stuff for data types
+ data_cons = tyConDataCons tycon
+ match_results = [match_result | (_,_,match_result) <- match_alts]
-combineMatchResults :: MatchResult -> MatchResult -> DsM MatchResult
-combineMatchResults (MatchResult CanFail ty1 body_fn1 cxt1)
- (MatchResult can_it_fail2 ty2 body_fn2 cxt2)
- = mkFailurePair ty1 `thenDs` \ (bind_fn, duplicatable_expr) ->
- let
- new_body_fn1 = \body1 -> Let (bind_fn body1) (body_fn1 duplicatable_expr)
- new_body_fn2 = \body2 -> new_body_fn1 (body_fn2 body2)
- in
- returnDs (MatchResult can_it_fail2 ty1 new_body_fn2 cxt1)
+ fail_flag | exhaustive_case
+ = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results]
+ | otherwise
+ = CanFail
-combineMatchResults match_result1@(MatchResult CantFail ty body_fn1 cxt1)
- match_result2
- = returnDs match_result1
+ 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_alt fail (con, args, MatchResult _ body_fn)
+ = body_fn fail `thenDs` \ body ->
+ newUniqueSupply `thenDs` \ us ->
+ returnDs (mkReboxingAlt (uniqsFromSupply us) con args body)
--- The difference in combineGRHSMatchResults is that there is no
--- need to let-bind to avoid code duplication
-combineGRHSMatchResults :: MatchResult -> MatchResult -> DsM MatchResult
-combineGRHSMatchResults (MatchResult CanFail ty1 body_fn1 cxt1)
- (MatchResult can_it_fail ty2 body_fn2 cxt2)
- = returnDs (MatchResult can_it_fail ty1 (\ body -> body_fn1 (body_fn2 body)) cxt1)
+ mk_default fail | exhaustive_case = []
+ | otherwise = [(DEFAULT, [], fail)]
-combineGRHSMatchResults match_result1 match_result2
- = -- Delegate to avoid duplication of code
- combineMatchResults match_result1 match_result2
+ un_mentioned_constructors
+ = mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts]
+ exhaustive_case = isEmptyUniqSet un_mentioned_constructors
+
+ -- Stuff for parallel arrays
+ --
+ -- * the following is to desugar cases over fake constructors for
+ -- parallel arrays, which are introduced by `tidy1' in the `PArrPat'
+ -- case
+ --
+ -- Concerning `isPArrFakeAlts':
+ --
+ -- * it is *not* sufficient to just check the type of the type
+ -- constructor, as we have to be careful not to confuse the real
+ -- representation of parallel arrays with the fake constructors;
+ -- moreover, a list of alternatives must not mix fake and real
+ -- constructors (this is checked earlier on)
+ --
+ -- FIXME: We actually go through the whole list and make sure that
+ -- either all or none of the constructors are fake parallel
+ -- array constructors. This is to spot equations that mix fake
+ -- constructors with the real representation defined in
+ -- `PrelPArr'. It would be nicer to spot this situation
+ -- earlier and raise a proper error message, but it can really
+ -- only happen in `PrelPArr' anyway.
+ --
+ isPArrFakeAlts [(dcon, _, _)] = isPArrFakeCon dcon
+ isPArrFakeAlts ((dcon, _, _):alts) =
+ case (isPArrFakeCon dcon, isPArrFakeAlts alts) of
+ (True , True ) -> True
+ (False, False) -> False
+ _ ->
+ panic "DsUtils: You may not mix `[:...:]' with `PArr' patterns"
+ --
+ mk_parrCase fail =
+ dsLookupGlobalId lengthPName `thenDs` \lengthP ->
+ unboxAlt `thenDs` \alt ->
+ returnDs (Case (len lengthP) (mkWildId intTy) ty [alt])
+ where
+ elemTy = case splitTyConApp (idType var) of
+ (_, [elemTy]) -> elemTy
+ _ -> panic panicMsg
+ 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)))
+ where
+ wild = mkWildId intPrimTy
+ dft = (DEFAULT, [], fail)
+ --
+ -- each alternative matches one array length (corresponding to one
+ -- fake array constructor), so the match is on a literal; each
+ -- alternative's body is extended by a local binding for each
+ -- 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)
+ 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[dsExprToAtom]{Take an expression and produce an atom}
+\subsection{Desugarer's versions of some Core functions}
%* *
%************************************************************************
\begin{code}
-dsExprToAtom :: DsCoreArg -- The argument expression
- -> (CoreArg -> DsM CoreExpr) -- Something taking the argument *atom*,
- -- and delivering an expression E
- -> DsM CoreExpr -- Either E or let x=arg-expr in E
-
-dsExprToAtom (UsageArg u) continue_with = continue_with (UsageArg u)
-dsExprToAtom (TyArg t) continue_with = continue_with (TyArg t)
-dsExprToAtom (LitArg l) continue_with = continue_with (LitArg l)
-
-dsExprToAtom (VarArg (Var v)) continue_with = continue_with (VarArg v)
-dsExprToAtom (VarArg (Lit v)) continue_with = continue_with (LitArg v)
+mkErrorAppDs :: Id -- The error function
+ -> Type -- Type to which it should be applied
+ -> String -- The error message string to pass
+ -> DsM CoreExpr
-dsExprToAtom (VarArg arg_expr) continue_with
- = let
- ty = coreExprType arg_expr
+mkErrorAppDs err_id ty msg
+ = getSrcSpanDs `thenDs` \ src_loc ->
+ let
+ full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg])
+ core_msg = Lit (mkStringLit full_msg)
in
- newSysLocalDs ty `thenDs` \ arg_id ->
- continue_with (VarArg arg_id) `thenDs` \ body ->
- returnDs (
- if isUnboxedType ty
- then Case arg_expr (PrimAlts [] (BindDefault arg_id body))
- else Let (NonRec arg_id arg_expr) body
- )
-
-dsExprsToAtoms :: [DsCoreArg]
- -> ([CoreArg] -> DsM CoreExpr)
- -> DsM CoreExpr
-
-dsExprsToAtoms [] continue_with = continue_with []
-
-dsExprsToAtoms (arg:args) continue_with
- = dsExprToAtom arg $ \ arg_atom ->
- dsExprsToAtoms args $ \ arg_atoms ->
- continue_with (arg_atom:arg_atoms)
+ returnDs (mkApps (Var err_id) [Type ty, core_msg])
\end{code}
-%************************************************************************
+
+*************************************************************
%* *
-\subsection{Desugarer's versions of some Core functions}
+\subsection{Making literals}
%* *
%************************************************************************
\begin{code}
-type DsCoreArg = GenCoreArg CoreExpr{-NB!-} TyVar UVar
+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
-mkAppDs :: CoreExpr -> [DsCoreArg] -> DsM CoreExpr
-mkConDs :: Id -> [DsCoreArg] -> DsM CoreExpr
-mkPrimDs :: PrimOp -> [DsCoreArg] -> DsM CoreExpr
+ in
+ returnDs (horner tARGET_MAX_INT i)
-mkAppDs fun args
- = dsExprsToAtoms args $ \ atoms ->
- returnDs (mkGenApp fun atoms)
+mkSmallIntegerLit small_integer_data_con i = mkConApp small_integer_data_con [mkIntLit i]
-mkConDs con args
- = dsExprsToAtoms args $ \ atoms ->
- returnDs (Con con atoms)
+mkStringExpr str = mkStringExprFS (mkFastString str)
-mkPrimDs op args
- = dsExprsToAtoms args $ \ atoms ->
- returnDs (Prim op atoms)
-\end{code}
+mkStringExprFS str
+ | nullFastString str
+ = returnDs (mkNilExpr charTy)
-\begin{code}
-showForErr :: Outputable a => a -> String -- Boring but useful
-showForErr thing = ppShow 80 (ppr PprForUser thing)
+ | lengthFS str == 1
+ = let
+ the_char = mkCharExpr (headFS str)
+ in
+ returnDs (mkConsExpr charTy the_char (mkNilExpr charTy))
-mkErrorAppDs :: Id -- The error function
- -> Type -- Type to which it should be applied
- -> String -- The error message string to pass
- -> DsM CoreExpr
+ | all safeChar int_chars
+ = dsLookupGlobalId unpackCStringName `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr str)))
-mkErrorAppDs err_id ty msg
- = getSrcLocDs `thenDs` \ (file, line) ->
- let
- full_msg = file ++ "|" ++ line ++ "|" ++msg
- msg_lit = NoRepStr (_PK_ full_msg)
- in
- returnDs (mkApp (Var err_id) [] [ty] [LitArg msg_lit])
+ | otherwise
+ = dsLookupGlobalId unpackCStringUtf8Name `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr (mkFastString (intsToUtf8 int_chars)))))
+
+ where
+ int_chars = unpackIntFS str
+ safeChar c = c >= 1 && c <= 0xFF
\end{code}
+
%************************************************************************
%* *
\subsection[mkSelectorBind]{Make a selector bind}
This is used in various places to do with lazy patterns.
For each binder $b$ in the pattern, we create a binding:
-
+\begin{verbatim}
b = case v of pat' -> b'
-
-where pat' is pat with each binder b cloned into b'.
+\end{verbatim}
+where @pat'@ is @pat@ with each binder @b@ cloned into @b'@.
ToDo: making these bindings should really depend on whether there's
much work to be done per binding. If the pattern is complex, it
expressions.
\begin{code}
-mkSelectorBinds :: [TyVar] -- Variables wrt which the pattern is polymorphic
- -> TypecheckedPat -- The pattern
- -> [(Id,Id)] -- Monomorphic and polymorphic binders for
- -- the pattern
- -> CoreExpr -- Expression to which the pattern is bound
+mkSelectorBinds :: LPat Id -- The pattern
+ -> CoreExpr -- Expression to which the pattern is bound
-> DsM [(Id,CoreExpr)]
-mkSelectorBinds tyvars pat locals_and_globals val_expr
- = if is_simple_tuple_pat pat then
- mkTupleBind tyvars [] locals_and_globals val_expr
- else
- mkErrorAppDs iRREFUT_PAT_ERROR_ID res_ty "" `thenDs` \ error_msg ->
- matchSimply val_expr pat res_ty local_tuple error_msg `thenDs` \ tuple_expr ->
- mkTupleBind tyvars [] locals_and_globals tuple_expr
- where
- locals = [local | (local, _) <- locals_and_globals]
- local_tuple = mkTupleExpr locals
- res_ty = coreExprType local_tuple
+mkSelectorBinds (L _ (VarPat v)) val_expr
+ = returnDs [(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 (hsPatType 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 )
- is_simple_tuple_pat (TuplePat ps) = all is_var_pat ps
- is_simple_tuple_pat other = False
- is_var_pat (VarPat v) = True
- is_var_pat other = False -- Even wild-card patterns aren't acceptable
-\end{code}
-
-We're about to match against some patterns. We want to make some
-@Ids@ to use as match variables. If a pattern has an @Id@ readily at
-hand, which should indeed be bound to the pattern as a whole, then use it;
-otherwise, make one up.
-\begin{code}
-selectMatchVars :: [TypecheckedPat] -> DsM [Id]
-selectMatchVars pats
- = mapDs var_from_pat_maybe pats
+ | 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 )
where
- var_from_pat_maybe (VarPat var) = returnDs var
- var_from_pat_maybe (AsPat var pat) = returnDs var
- var_from_pat_maybe (LazyPat pat) = var_from_pat_maybe pat
- var_from_pat_maybe other_pat
- = newSysLocalDs (outPatType other_pat) -- OK, better make up one...
-\end{code}
+ binders = collectPatBinders pat
+ local_tuple = mkTupleExpr binders
+ tuple_ty = exprType local_tuple
+
+ mk_bind scrut_var err_var bndr_var
+ -- (mk_bind sv err_var) generates
+ -- 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)
+ where
+ error_expr = mkCoerce (idType bndr_var) (Var err_var)
-\begin{code}
-mkTupleBind :: [TyVar] -- Abstract wrt these...
- -> [DictVar] -- ... and these
+ is_simple_lpat p = is_simple_pat (unLoc p)
- -> [(Id, Id)] -- Local, global pairs, equal in number
- -- to the size of the tuple. The types
- -- of the globals is the generalisation of
- -- the corresp local, wrt the tyvars and dicts
+ is_simple_pat (TuplePat ps Boxed) = all is_triv_lpat ps
+ is_simple_pat (ConPatOut _ _ _ _ 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
- -> CoreExpr -- Expr whose value is a tuple; the expression
- -- may mention the tyvars and dicts
+ is_triv_lpat p = is_triv_pat (unLoc p)
- -> DsM [(Id, CoreExpr)] -- Bindings for the globals
+ is_triv_pat (VarPat v) = True
+ is_triv_pat (WildPat _) = True
+ is_triv_pat (ParPat p) = is_triv_lpat p
+ is_triv_pat other = False
\end{code}
-The general call is
-\begin{verbatim}
- mkTupleBind tyvars dicts [(l1,g1), ..., (ln,gn)] tup_expr
-\end{verbatim}
-If $n=1$, the result is:
-\begin{verbatim}
- g1 = /\ tyvars -> \ dicts -> rhs
-\end{verbatim}
-Otherwise, the result is:
-\begin{verbatim}
- tup = /\ tyvars -> \ dicts -> tup_expr
- g1 = /\ tyvars -> \ dicts -> case (tup tyvars dicts) of
- (l1, ..., ln) -> l1
- ...etc...
-\end{verbatim}
-\begin{code}
-mkTupleBind tyvars dicts [(local,global)] tuple_expr
- = returnDs [(global, mkLam tyvars dicts tuple_expr)]
-\end{code}
+%************************************************************************
+%* *
+ Tuples
+%* *
+%************************************************************************
-The general case:
+@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@.
-\begin{code}
-mkTupleBind tyvars dicts local_global_prs tuple_expr
- = --pprTrace "mkTupleBind:\n" (ppAboves [ppCat (map (pprId PprShowAll) locals), ppCat (map (pprId PprShowAll) globals), {-ppr PprDebug local_tuple, pprType PprDebug res_ty,-} ppr PprDebug tuple_expr]) $
-
- newSysLocalDs tuple_var_ty `thenDs` \ tuple_var ->
-
- zipWithDs (mk_selector (Var tuple_var))
- local_global_prs
- [(0::Int) .. (length local_global_prs - 1)]
- `thenDs` \ tup_selectors ->
- returnDs (
- (tuple_var, mkLam tyvars dicts tuple_expr)
- : tup_selectors
- )
- where
- locals, globals :: [Id]
- locals = [local | (local,global) <- local_global_prs]
- globals = [global | (local,global) <- local_global_prs]
-
- no_of_binders = length local_global_prs
- tyvar_tys = mkTyVarTys tyvars
-
- tuple_var_ty :: Type
- tuple_var_ty
- = mkForAllTys tyvars $
- mkRhoTy theta $
- applyTyCon (mkTupleTyCon no_of_binders)
- (map idType locals)
- where
- theta = mkTheta (map idType dicts)
+* If it has only one element, it is the identity function.
- mk_selector :: CoreExpr -> (Id, Id) -> Int -> DsM (Id, CoreExpr)
+* If there are more elements than a big tuple can have, it nests
+ the tuples.
- mk_selector tuple_var_expr (local, global) which_local
- = mapDs duplicateLocalDs locals{-the whole bunch-} `thenDs` \ binders ->
- let
- selected = binders !! which_local
- in
- returnDs (
- global,
- mkLam tyvars dicts (
- mkTupleSelector
- (mkValApp (mkTyApp tuple_var_expr tyvar_tys)
- (map VarArg dicts))
- binders
- selected)
- )
-\end{code}
+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.
-@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. If it
-has only one element, it is the identity function.
\begin{code}
mkTupleExpr :: [Id] -> CoreExpr
+mkTupleExpr ids = mkBigCoreTup (map Var ids)
+
+-- corresponding type
+mkTupleType :: [Id] -> Type
+mkTupleType ids = mkBigTuple mkCoreTupTy (map idType ids)
-mkTupleExpr [] = Con (mkTupleCon 0) []
-mkTupleExpr [id] = Var id
-mkTupleExpr ids = mkCon (mkTupleCon (length ids))
- [{-usages-}]
- (map idType ids)
- [ VarArg i | i <- 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}
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
+
\begin{code}
-mkTupleSelector :: CoreExpr -- Scrutinee
- -> [Id] -- The tuple args
- -> Id -- The selected one
+mkTupleSelector :: [Id] -- The tuple args
+ -> Id -- The selected one
+ -> Id -- A variable of the same type as the scrutinee
+ -> CoreExpr -- Scrutinee
-> CoreExpr
-mkTupleSelector expr [] the_var = panic "mkTupleSelector"
+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.
-mkTupleSelector expr [var] should_be_the_same_var
+ToDo: eliminate cases where none of the variables are needed.
+
+\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)
- expr
+ scrut
-mkTupleSelector expr vars the_var
- = Case expr (AlgAlts [(mkTupleCon arity, vars, Var the_var)]
- NoDefault)
- where
- arity = length vars
+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)]
\end{code}
Then
\begin{itemize}
\item
-If the case can't fail, then there'll be no mention of fail.33, and the
+If the case can't fail, then there'll be no mention of @fail.33@, and the
simplifier will later discard it.
\item
\end{itemize}
There's a problem when the result of the case expression is of
-unboxed type. Then the type of fail.33 is unboxed too, and
+unboxed type. Then the type of @fail.33@ is unboxed too, and
there is every chance that someone will change the let into a case:
\begin{verbatim}
case error "Help" of
p4 -> ...
\end{verbatim}
-Now fail.33 is a function, so it can be let-bound.
+Now @fail.33@ is a function, so it can be let-bound.
\begin{code}
-mkFailurePair :: Type -- Result type of the whole case expression
- -> DsM (CoreExpr -> CoreBinding,
- -- Binds the newly-created fail variable
+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
-mkFailurePair ty
- | isUnboxedType ty
- = newFailLocalDs (voidTy `mkFunTy` ty) `thenDs` \ fail_fun_var ->
- newSysLocalDs voidTy `thenDs` \ fail_fun_arg ->
- returnDs (\ body ->
- NonRec fail_fun_var (Lam (ValBinder fail_fun_arg) body),
- App (Var fail_fun_var) (VarArg voidId))
+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 (\ body -> NonRec fail_var body, Var fail_var)
+ returnDs (NonRec fail_var expr, Var fail_var)
+ where
+ ty = exprType expr
\end{code}
-
projects / ghc-hetmet.git / blobdiff