X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FdeSugar%2FDsUtils.lhs;h=81aaf42b535c84ce337fb0652314b8bf46fa6e3c;hb=111cee3f1ad93816cb828e38b38521d85c3bcebb;hp=90fb7084f80c971e6671e35761c5aad4a6c56725;hpb=8be8b43bc916989adcced08fbfb166e3fca7c508;p=ghc-hetmet.git diff --git a/ghc/compiler/deSugar/DsUtils.lhs b/ghc/compiler/deSugar/DsUtils.lhs index 90fb708..81aaf42 100644 --- a/ghc/compiler/deSugar/DsUtils.lhs +++ b/ghc/compiler/deSugar/DsUtils.lhs @@ -1,80 +1,153 @@ % -% (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(..), + EqnNo, EqnSet, + + tidyLitPat, + + mkDsLet, mkDsLets, + + cantFailMatchResult, extractMatchResult, + combineMatchResults, + adjustMatchResult, adjustMatchResultDs, + mkCoLetsMatchResult, mkGuardedMatchResult, + mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, - combineGRHSMatchResults, - combineMatchResults, - dsExprToAtomGivenTy, SYN_IE(DsCoreArg), - mkCoAlgCaseMatchResult, - mkAppDs, mkConDs, mkPrimDs, mkErrorAppDs, - mkCoLetsMatchResult, - mkCoPrimCaseMatchResult, - mkFailurePair, - mkGuardedMatchResult, - mkSelectorBinds, - mkTupleBind, - mkTupleExpr, - mkTupleSelector, - selectMatchVars, - showForErr + mkErrorAppDs, mkNilExpr, mkConsExpr, + + mkSelectorBinds, mkTupleExpr, mkTupleSelector, + + selectMatchVar ) where -IMP_Ubiq() -#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ <= 201 -IMPORT_DELOOPER(DsLoop) ( match, matchSimply ) -#else -import {-# SOURCE #-} Match (match, matchSimply ) -#endif +#include "HsVersions.h" + +import {-# SOURCE #-} Match ( matchSimply ) -import HsSyn ( HsExpr(..), OutPat(..), HsLit(..), Fixity, - Match, HsBinds, Stmt, DoOrListComp, HsType, ArithSeqInfo ) -import TcHsSyn ( SYN_IE(TypecheckedPat) ) +import HsSyn +import TcHsSyn ( TypecheckedPat ) import DsHsSyn ( outPatType, collectTypedPatBinders ) -import CmdLineOpts ( opt_PprUserLength ) import CoreSyn import DsMonad -import CoreUtils ( coreExprType, mkCoreIfThenElse ) -import PrelVals ( iRREFUT_PAT_ERROR_ID, voidId ) -import Pretty ( Doc, hcat, text ) -import Id ( idType, dataConArgTys, --- pprId{-ToDo:rm-}, - SYN_IE(DataCon), SYN_IE(DictVar), SYN_IE(Id), GenId ) -import Literal ( Literal(..) ) -import PprType ( GenType, GenTyVar ) -import PrimOp ( PrimOp ) +import CoreUtils ( exprType ) +import PrelInfo ( iRREFUT_PAT_ERROR_ID ) +import Id ( idType, Id, mkWildId ) +import Literal ( Literal ) import TyCon ( isNewTyCon, tyConDataCons ) -import Type ( mkTyVarTys, mkRhoTy, mkForAllTys, mkFunTy, - mkTheta, isUnboxedType, applyTyCon, getAppTyCon, - GenType {- instances -}, SYN_IE(Type) +import DataCon ( DataCon, StrictnessMark, maybeMarkedUnboxed, + dataConStrictMarks, dataConId, splitProductType_maybe ) -import TyVar ( GenTyVar {- instances -}, SYN_IE(TyVar) ) -import TysPrim ( voidTy ) -import TysWiredIn ( tupleTyCon, unitDataCon, tupleCon ) -import UniqSet ( mkUniqSet, minusUniqSet, uniqSetToList, SYN_IE(UniqSet) ) -import Util ( panic, assertPanic{-, pprTrace ToDo:rm-} ) -import Unique ( Unique ) -import Usage ( SYN_IE(UVar) ) -import SrcLoc ( SrcLoc {- instance Outputable -} ) - +import Type ( mkFunTy, isUnLiftedType, splitAlgTyConApp, unUsgTy, + Type + ) +import TysPrim ( intPrimTy, + charPrimTy, + floatPrimTy, + doublePrimTy, + addrPrimTy, + wordPrimTy + ) +import TysWiredIn ( nilDataCon, consDataCon, + tupleCon, + stringTy, + unitDataConId, unitTy, + charTy, charDataCon, + intTy, intDataCon, + floatTy, floatDataCon, + doubleTy, doubleDataCon, + addrTy, addrDataCon, + wordTy, wordDataCon + ) +import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet, UniqSet ) import Outputable +\end{code} + + + +%************************************************************************ +%* * +\subsection{Tidying lit pats} +%* * +%************************************************************************ + +\begin{code} +tidyLitPat lit lit_ty default_pat + | lit_ty == charTy = ConPat charDataCon lit_ty [] [] [LitPat (mk_char lit) charPrimTy] + | lit_ty == intTy = ConPat intDataCon lit_ty [] [] [LitPat (mk_int lit) intPrimTy] + | lit_ty == wordTy = ConPat wordDataCon lit_ty [] [] [LitPat (mk_word lit) wordPrimTy] + | lit_ty == addrTy = ConPat addrDataCon lit_ty [] [] [LitPat (mk_addr lit) addrPrimTy] + | lit_ty == floatTy = ConPat floatDataCon lit_ty [] [] [LitPat (mk_float lit) floatPrimTy] + | lit_ty == doubleTy = ConPat doubleDataCon lit_ty [] [] [LitPat (mk_double lit) doublePrimTy] + + -- Convert the literal pattern "" to the constructor pattern []. + | null_str_lit lit = ConPat nilDataCon lit_ty [] [] [] + -- Similar special case for "x" + | one_str_lit lit = ConPat consDataCon lit_ty [] [] + [mk_first_char_lit lit, ConPat nilDataCon lit_ty [] [] []] + + | otherwise = default_pat + + where + mk_int (HsInt i) = HsIntPrim i + mk_int l@(HsLitLit s) = l + + mk_char (HsChar c) = HsCharPrim c + mk_char l@(HsLitLit s) = l + + mk_word l@(HsLitLit s) = l + + mk_addr l@(HsLitLit s) = l + + mk_float (HsInt i) = HsFloatPrim (fromInteger i) + mk_float (HsFrac f) = HsFloatPrim f + mk_float l@(HsLitLit s) = l + + mk_double (HsInt i) = HsDoublePrim (fromInteger i) + mk_double (HsFrac f) = HsDoublePrim f + mk_double l@(HsLitLit s) = l + + null_str_lit (HsString s) = _NULL_ s + null_str_lit other_lit = False + + one_str_lit (HsString s) = _LENGTH_ s == (1::Int) + one_str_lit other_lit = False + mk_first_char_lit (HsString s) = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim (_HEAD_ s)) charPrimTy] +\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 [(DEFAULT,[],body)] +mkDsLet bind body + = Let bind body + +mkDsLets :: [CoreBind] -> CoreExpr -> CoreExpr +mkDsLets binds body = foldr mkDsLet body binds \end{code} %************************************************************************ %* * -%* Selecting match variables +\subsection{ Selecting match variables} %* * %************************************************************************ @@ -84,15 +157,11 @@ 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 - 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... +selectMatchVar :: TypecheckedPat -> DsM Id +selectMatchVar (VarPat var) = returnDs var +selectMatchVar (AsPat var pat) = returnDs var +selectMatchVar (LazyPat pat) = selectMatchVar pat +selectMatchVar other_pat = newSysLocalDs (outPatType other_pat) -- OK, better make up one... \end{code} @@ -107,212 +176,186 @@ The ``equation info'' used by @match@ is relatively complicated and worthy of a type synonym and a few handy functions. \begin{code} + +type EqnNo = Int +type EqnSet = UniqSet EqnNo + data EquationInfo = EqnInfo - [TypecheckedPat] -- the patterns for an eqn + EqnNo -- The number of the equation + + 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! + + [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 - - (CoreExpr -> CoreExpr) + CanItFail -- Tells whether the failure expression is used + (CoreExpr -> DsM CoreExpr) -- Takes a expression to plug in at the -- failure point(s). The expression should -- be duplicatable! - 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! - data CanItFail = CanFail | CantFail orFail CantFail CantFail = CantFail orFail _ _ = CanFail +\end{code} + +Functions on MatchResults + +\begin{code} +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!") + +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) + + +combineMatchResults :: MatchResult -> MatchResult -> MatchResult +combineMatchResults (MatchResult CanFail body_fn1) + (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) + +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)) -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 +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) -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 - ) + +mkCoLetsMatchResult :: [CoreBind] -> MatchResult -> MatchResult +mkCoLetsMatchResult binds match_result + = adjustMatchResult (mkDsLets binds) 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)) 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) + -> [(Literal, MatchResult)] -- Alternatives + -> MatchResult +mkCoPrimCaseMatchResult var match_alts + = MatchResult CanFail mk_case where - ((_,MatchResult _ ty1 _ cxt1) : _) = alts + mk_case fail + = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> + returnDs (Case (Var var) var (alts ++ [(DEFAULT, [], 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 - ] + mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body -> + returnDs (LitAlt lit, [], body) -mkCoAlgCaseMatchResult :: Id -- Scrutinee - -> [(DataCon, [Id], MatchResult)] -- Alternatives - -> DsM MatchResult +mkCoAlgCaseMatchResult :: Id -- Scrutinee + -> [(DataCon, [CoreBndr], MatchResult)] -- Alternatives + -> MatchResult -mkCoAlgCaseMatchResult var alts - | isNewTyCon tycon -- newtype case; use a let +mkCoAlgCaseMatchResult var match_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) + mkCoLetsMatchResult [coercion_bind] match_result + + | otherwise -- Datatype case; use a case + = MatchResult fail_flag mk_case where -- Common stuff scrut_ty = idType var - (tycon, tycon_arg_tys) = --pprTrace "CoAlgCase:" (pprType PprDebug scrut_ty) $ - getAppTyCon scrut_ty + (tycon, tycon_arg_tys, _) = splitAlgTyConApp scrut_ty -- Stuff for newtype - (con_id, arg_ids, match_result) = head alts + (con_id, arg_ids, match_result) = head match_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) + coercion_bind = NonRec arg_id + (Note (Coerce (unUsgTy (idType arg_id)) (unUsgTy scrut_ty)) (Var var)) + newtype_sanity = null (tail match_alts) && null (tail arg_ids) -- Stuff for data types data_cons = tyConDataCons tycon - un_mentioned_constructors - = uniqSetToList (mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- alts] ) + match_results = [match_result | (_,_,match_result) <- match_alts] - 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] + fail_flag | exhaustive_case + = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results] + | otherwise + = CanFail - 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 - ] + wild_var = mkWildId (idType var) + mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> + returnDs (Case (Var var) wild_var (alts ++ mk_default fail)) + mk_alt fail (con, args, MatchResult _ body_fn) + = body_fn fail `thenDs` \ body -> + rebuildConArgs con args (dataConStrictMarks con) body + `thenDs` \ (body', real_args) -> + returnDs (DataAlt con, real_args, body') -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) + mk_default fail | exhaustive_case = [] + | otherwise = [(DEFAULT, [], fail)] -combineMatchResults match_result1@(MatchResult CantFail ty body_fn1 cxt1) - match_result2 - = returnDs match_result1 - - --- 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) - -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 \end{code} - -%************************************************************************ -%* * -\subsection[dsExprToAtom]{Take an expression and produce an atom} -%* * -%************************************************************************ - +% +For each constructor we match on, we might need to re-pack some +of the strict fields if they are unpacked in the constructor. +% \begin{code} -dsArgToAtom :: 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 - -dsArgToAtom (UsageArg u) continue_with = continue_with (UsageArg u) -dsArgToAtom (TyArg t) continue_with = continue_with (TyArg t) -dsArgToAtom (LitArg l) continue_with = continue_with (LitArg l) -dsArgToAtom (VarArg arg) continue_with = dsExprToAtomGivenTy arg (coreExprType arg) continue_with - -dsExprToAtomGivenTy - :: CoreExpr -- The argument expression - -> Type -- Type of the argument - -> (CoreArg -> DsM CoreExpr) -- Something taking the argument *atom*, - -- and delivering an expression E - -> DsM CoreExpr -- Either E or let x=arg-expr in E - -dsExprToAtomGivenTy (Var v) arg_ty continue_with = continue_with (VarArg v) -dsExprToAtomGivenTy (Lit v) arg_ty continue_with = continue_with (LitArg v) -dsExprToAtomGivenTy arg_expr arg_ty continue_with - = newSysLocalDs arg_ty `thenDs` \ arg_id -> - continue_with (VarArg arg_id) `thenDs` \ body -> - returnDs ( - if isUnboxedType arg_ty - then Case arg_expr (PrimAlts [] (BindDefault arg_id body)) - else Let (NonRec arg_id arg_expr) body - ) - -dsArgsToAtoms :: [DsCoreArg] - -> ([CoreArg] -> DsM CoreExpr) - -> DsM CoreExpr - -dsArgsToAtoms [] continue_with = continue_with [] - -dsArgsToAtoms (arg:args) continue_with - = dsArgToAtom arg $ \ arg_atom -> - dsArgsToAtoms args $ \ arg_atoms -> - continue_with (arg_atom:arg_atoms) +rebuildConArgs + :: DataCon -- the con we're matching on + -> [Id] -- the source-level args + -> [StrictnessMark] -- the strictness annotations (per-arg) + -> CoreExpr -- the body + -> DsM (CoreExpr, [Id]) + +rebuildConArgs con [] stricts body = returnDs (body, []) +rebuildConArgs con (arg:args) stricts body | isTyVar arg + = rebuildConArgs con args stricts body `thenDs` \ (body', args') -> + returnDs (body',arg:args') +rebuildConArgs con (arg:args) (str:stricts) body + = rebuildConArgs con args stricts body `thenDs` \ (body', real_args) -> + case maybeMarkedUnboxed str of + Just (pack_con1, _) -> + case splitProductType_maybe (idType arg) of + Just (_, tycon_args, pack_con, con_arg_tys) -> + ASSERT( pack_con == pack_con1 ) + newSysLocalsDs con_arg_tys `thenDs` \ unpacked_args -> + returnDs ( + mkDsLet (NonRec arg (mkConApp pack_con + (map Type tycon_args ++ + map Var unpacked_args))) body', + unpacked_args ++ real_args + ) + + _ -> returnDs (body', arg:real_args) \end{code} %************************************************************************ @@ -322,29 +365,6 @@ dsArgsToAtoms (arg:args) continue_with %************************************************************************ \begin{code} -type DsCoreArg = GenCoreArg CoreExpr{-NB!-} TyVar UVar - -mkAppDs :: CoreExpr -> [DsCoreArg] -> DsM CoreExpr -mkConDs :: Id -> [DsCoreArg] -> DsM CoreExpr -mkPrimDs :: PrimOp -> [DsCoreArg] -> DsM CoreExpr - -mkAppDs fun args - = dsArgsToAtoms args $ \ atoms -> - returnDs (mkGenApp fun atoms) - -mkConDs con args - = dsArgsToAtoms args $ \ atoms -> - returnDs (Con con atoms) - -mkPrimDs op args - = dsArgsToAtoms args $ \ atoms -> - returnDs (Prim op atoms) -\end{code} - -\begin{code} -showForErr :: Outputable a => a -> String -- Boring but useful -showForErr thing = show (ppr PprQuote thing) - mkErrorAppDs :: Id -- The error function -> Type -- Type to which it should be applied -> String -- The error message string to pass @@ -353,10 +373,10 @@ mkErrorAppDs :: Id -- The error function mkErrorAppDs err_id ty msg = getSrcLocDs `thenDs` \ src_loc -> let - full_msg = show (hcat [ppr (PprForUser opt_PprUserLength) src_loc, text "|", text msg]) - msg_lit = NoRepStr (_PK_ full_msg) + full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg]) in - returnDs (mkApp (Var err_id) [] [ty] [LitArg msg_lit]) + returnDs (mkApps (Var err_id) [(Type . unUsgTy) ty, mkStringLit full_msg]) + -- unUsgTy *required* -- KSW 1999-04-07 \end{code} %************************************************************************ @@ -367,10 +387,10 @@ mkErrorAppDs err_id ty msg 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 @@ -390,59 +410,73 @@ mkSelectorBinds (VarPat v) val_expr = returnDs [(v, val_expr)] mkSelectorBinds pat val_expr - | is_simple_tuple_pat pat - = mkTupleBind binders val_expr - - | otherwise - = mkErrorAppDs iRREFUT_PAT_ERROR_ID res_ty pat_string `thenDs` \ error_msg -> - matchSimply val_expr pat res_ty local_tuple error_msg `thenDs` \ tuple_expr -> - mkTupleBind binders tuple_expr - - where - binders = collectTypedPatBinders pat - local_tuple = mkTupleExpr binders - res_ty = coreExprType local_tuple - - 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 - - pat_string = show (ppr (PprForUser opt_PprUserLength) pat) -\end{code} - - -\begin{code} -mkTupleBind :: [Id] -- Names of tuple components - -> CoreExpr -- Expr whose value is a tuple of correct type - -> DsM [(Id, CoreExpr)] -- Bindings for the globals + | length binders == 1 || is_simple_pat pat + = newSysLocalDs (exprType val_expr) `thenDs` \ val_var -> + -- For the error message we don't use mkErrorAppDs to avoid + -- duplicating the string literal each time + newSysLocalDs stringTy `thenDs` \ msg_var -> + getSrcLocDs `thenDs` \ src_loc -> + let + full_msg = showSDoc (hcat [ppr src_loc, text "|", ppr pat]) + in + mapDs (mk_bind val_var msg_var) binders `thenDs` \ binds -> + returnDs ( (val_var, val_expr) : + (msg_var, mkStringLit full_msg) : + binds ) -mkTupleBind [local] tuple_expr - = returnDs [(local, tuple_expr)] -mkTupleBind locals tuple_expr - = newSysLocalDs (coreExprType tuple_expr) `thenDs` \ tuple_var -> + | otherwise + = mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (showSDoc (ppr pat)) + `thenDs` \ error_expr -> + matchSimply val_expr LetMatch pat local_tuple error_expr + `thenDs` \ tuple_expr -> + newSysLocalDs tuple_ty + `thenDs` \ tuple_var -> let - mk_bind local = (local, mkTupleSelector locals local (Var tuple_var)) + mk_tup_bind binder = + (binder, mkTupleSelector binders binder tuple_var (Var tuple_var)) in - returnDs ( (tuple_var, tuple_expr) : - map mk_bind locals ) + returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders ) + where + binders = collectTypedPatBinders pat + local_tuple = mkTupleExpr binders + tuple_ty = exprType local_tuple + + mk_bind scrut_var msg_var bndr_var + -- (mk_bind sv bv) generates + -- bv = case sv of { pat -> bv; other -> error-msg } + -- Remember, pat binds bv + = matchSimply (Var scrut_var) LetMatch pat + (Var bndr_var) error_expr `thenDs` \ rhs_expr -> + returnDs (bndr_var, rhs_expr) + where + binder_ty = idType bndr_var + error_expr = mkApps (Var iRREFUT_PAT_ERROR_ID) [Type binder_ty, Var msg_var] + + is_simple_pat (TuplePat ps True{-boxed-}) = all is_triv_pat ps + is_simple_pat (ConPat _ _ _ _ ps) = all is_triv_pat ps + is_simple_pat (VarPat _) = True + is_simple_pat (RecPat _ _ _ _ ps) = and [is_triv_pat p | (_,p,_) <- ps] + is_simple_pat other = False + + is_triv_pat (VarPat v) = True + is_triv_pat (WildPat _) = True + is_triv_pat other = False \end{code} @mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. If it -has only one element, it is the identity function. +has only one element, it is the identity function. Notice we must +throw out any usage annotation on the outside of an Id. + \begin{code} mkTupleExpr :: [Id] -> CoreExpr -mkTupleExpr [] = Con unitDataCon [] +mkTupleExpr [] = Var unitDataConId mkTupleExpr [id] = Var id -mkTupleExpr ids = mkCon (tupleCon (length ids)) - [{-usages-}] - (map idType ids) - [ VarArg i | i <- ids ] +mkTupleExpr ids = mkConApp (tupleCon (length ids)) + (map (Type . unUsgTy . idType) ids ++ [ Var i | i <- ids ]) \end{code} @@ -456,22 +490,37 @@ If there is just one id in the ``tuple'', then the selector is just the identity. \begin{code} -mkTupleSelector :: [Id] -- The tuple args - -> Id -- The selected one - -> CoreExpr -- Scrutinee +mkTupleSelector :: [Id] -- The tuple args + -> Id -- The selected one + -> Id -- A variable of the same type as the scrutinee + -> CoreExpr -- Scrutinee -> CoreExpr -mkTupleSelector [] the_var scrut = panic "mkTupleSelector" - -mkTupleSelector [var] should_be_the_same_var scrut +mkTupleSelector [var] should_be_the_same_var scrut_var scrut = ASSERT(var == should_be_the_same_var) scrut -mkTupleSelector vars the_var scrut - = Case scrut (AlgAlts [(tupleCon arity, vars, Var the_var)] - NoDefault) - where - arity = length vars +mkTupleSelector vars the_var scrut_var scrut + = ASSERT( not (null vars) ) + Case scrut scrut_var [(DataAlt (tupleCon (length vars)), vars, Var the_var)] +\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 = App (Var (dataConId nilDataCon)) (Type ty) + +mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr +mkConsExpr ty hd tl = mkApps (Var (dataConId consDataCon)) [Type ty, hd, tl] \end{code} @@ -495,7 +544,7 @@ fail-variable, and use that variable if the thing fails: 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 @@ -506,7 +555,7 @@ Only if it is used more than once will the let-binding remain. \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 @@ -527,26 +576,26 @@ for the primitive case: 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}