%
-% (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,
+
+ mkErrorAppDs, mkNilExpr, mkConsExpr,
+ mkStringLit, mkStringLitFS,
- combineGRHSMatchResults,
- combineMatchResults,
- dsExprToAtom,
- mkCoAlgCaseMatchResult,
- mkAppDs, mkConDs, mkPrimDs, mkErrorAppDs,
- mkCoLetsMatchResult,
- mkCoPrimCaseMatchResult,
- mkFailurePair,
- mkGuardedMatchResult,
- mkSelectorBinds,
- mkTupleBind,
- mkTupleExpr,
- selectMatchVars,
- showForErr
+ mkSelectorBinds, mkTupleExpr, mkTupleSelector,
+
+ selectMatchVar
) where
-import Ubiq
-import DsLoop ( match, matchSimply )
+#include "HsVersions.h"
+
+import {-# SOURCE #-} Match ( matchSimply )
-import HsSyn ( HsExpr(..), OutPat(..), HsLit(..),
- Match, HsBinds, Stmt, Qual, PolyType, ArithSeqInfo )
-import TcHsSyn ( TypecheckedPat(..) )
-import DsHsSyn ( outPatType )
+import HsSyn
+import TcHsSyn ( TypecheckedPat )
+import DsHsSyn ( outPatType, collectTypedPatBinders )
import CoreSyn
import DsMonad
-import CoreUtils ( coreExprType, mkCoreIfThenElse )
-import PprStyle ( PprStyle(..) )
-import PrelInfo ( stringTy, iRREFUT_PAT_ERROR_ID )
-import Pretty ( ppShow )
-import Id ( idType, dataConArgTys, mkTupleCon,
- DataCon(..), DictVar(..), Id(..), GenId )
+import CoreUtils ( exprType, mkIfThenElse )
+import PrelInfo ( iRREFUT_PAT_ERROR_ID )
+import Id ( idType, Id, mkWildId )
import Literal ( Literal(..) )
-import TyCon ( mkTupleTyCon )
-import Type ( mkTyVarTys, mkRhoTy, mkFunTys, isUnboxedType,
- applyTyCon, getAppDataTyCon
+import TyCon ( isNewTyCon, tyConDataCons )
+import DataCon ( DataCon, StrictnessMark, maybeMarkedUnboxed,
+ dataConStrictMarks, dataConId, splitProductType_maybe
+ )
+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, uniqSetToList, UniqSet(..) )
-import Util ( panic, assertPanic )
+import BasicTypes ( Boxity(..) )
+import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet, UniqSet )
+import Unique ( unpackCStringIdKey, unpackCStringUtf8IdKey )
+import Outputable
+import UnicodeUtil ( stringToUtf8 )
+\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 literal patterns like "foo" to 'f':'o':'o':[]
+ | str_lit lit = mk_list lit
+
+ | 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
+
+ str_lit (HsString s) = True
+ str_lit _ = False
+
+ mk_list (HsString s) = foldr
+ (\c pat -> ConPat consDataCon lit_ty [] [] [mk_char_lit c,pat])
+ (ConPat nilDataCon lit_ty [] [] []) (_UNPK_INT_ s)
+
+ mk_char_lit c = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) 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}
+
+
+%************************************************************************
+%* *
+\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.
-quantifyTy = panic "DsUtils.quantifyTy"
-splitDictType = panic "DsUtils.splitDictType"
-mkCoTyApps = panic "DsUtils.mkCoTyApps"
+\begin{code}
+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}
+
%************************************************************************
%* *
%* type synonym EquationInfo and access functions for its pieces *
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
-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
+\begin{code}
+cantFailMatchResult :: CoreExpr -> MatchResult
+cantFailMatchResult expr = MatchResult CantFail (\ ignore -> returnDs expr)
-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
- )
+extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr
+extractMatchResult (MatchResult CantFail match_fn) fail_expr
+ = match_fn (error "It can't 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)
+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
- ((_,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)
- 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
- = -- 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)
+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)
+
+
+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
+ -> MatchResult
+mkCoPrimCaseMatchResult var match_alts
+ = MatchResult CanFail mk_case
where
- scrut_ty = idType var
- (tycon, tycon_arg_tys, data_cons) = getAppDataTyCon scrut_ty
+ mk_case fail
+ = mapDs (mk_alt fail) match_alts `thenDs` \ alts ->
+ returnDs (Case (Var var) var (alts ++ [(DEFAULT, [], fail)]))
- un_mentioned_constructors
- = uniqSetToList (mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- alts] )
+ mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body ->
+ returnDs (LitAlt lit, [], body)
- 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]
- 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
- ]
+mkCoAlgCaseMatchResult :: Id -- Scrutinee
+ -> [(DataCon, [CoreBndr], MatchResult)] -- Alternatives
+ -> MatchResult
+mkCoAlgCaseMatchResult var match_alts
+ | isNewTyCon tycon -- Newtype case; use a let
+ = ASSERT( newtype_sanity )
+ mkCoLetsMatchResult [coercion_bind] match_result
-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)
+ | otherwise -- Datatype case; use a case
+ = MatchResult fail_flag mk_case
+ where
+ -- Common stuff
+ scrut_ty = idType var
+ (tycon, _, _) = splitAlgTyConApp scrut_ty
-combineMatchResults match_result1@(MatchResult CantFail ty body_fn1 cxt1)
- match_result2
- = returnDs match_result1
+ -- Stuff for newtype
+ (_, arg_ids, match_result) = head match_alts
+ arg_id = head 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
--- 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)
+ match_results = [match_result | (_,_,match_result) <- match_alts]
-combineGRHSMatchResults match_result1 match_result2
- = -- Delegate to avoid duplication of code
- combineMatchResults match_result1 match_result2
-\end{code}
+ fail_flag | exhaustive_case
+ = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results]
+ | otherwise
+ = CanFail
-%************************************************************************
-%* *
-\subsection[dsExprToAtom]{Take an expression and produce an atom}
-%* *
-%************************************************************************
+ 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))
-\begin{code}
-dsExprToAtom :: CoreExpr -- 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
+ 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')
-dsExprToAtom (Var v) continue_with = continue_with (VarArg v)
-dsExprToAtom (Lit v) continue_with = continue_with (LitArg v)
+ mk_default fail | exhaustive_case = []
+ | otherwise = [(DEFAULT, [], fail)]
-dsExprToAtom arg_expr continue_with
- = let
- ty = coreExprType arg_expr
- 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 :: [CoreExpr]
- -> ([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)
+ un_mentioned_constructors
+ = mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts]
+ exhaustive_case = isEmptyUniqSet un_mentioned_constructors
+\end{code}
+%
+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}
+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}
%************************************************************************
%************************************************************************
\begin{code}
-mkAppDs :: CoreExpr -> [Type] -> [CoreExpr] -> DsM CoreExpr
-mkConDs :: Id -> [Type] -> [CoreExpr] -> DsM CoreExpr
-mkPrimDs :: PrimOp -> [Type] -> [CoreExpr] -> DsM CoreExpr
-
-mkAppDs fun tys arg_exprs
- = dsExprsToAtoms arg_exprs $ \ vals ->
- returnDs (mkApp fun [] tys vals)
-
-mkConDs con tys arg_exprs
- = dsExprsToAtoms arg_exprs $ \ vals ->
- returnDs (mkCon con [] tys vals)
-
-mkPrimDs op tys arg_exprs
- = dsExprsToAtoms arg_exprs $ \ vals ->
- returnDs (mkPrim op [] tys vals)
-\end{code}
-
-\begin{code}
-showForErr :: Outputable a => a -> String -- Boring but useful
-showForErr thing = ppShow 80 (ppr PprForUser thing)
-
mkErrorAppDs :: Id -- The error function
-> Type -- Type to which it should be applied
-> String -- The error message string to pass
-> DsM CoreExpr
mkErrorAppDs err_id ty msg
- = getSrcLocDs `thenDs` \ (file, line) ->
+ = getSrcLocDs `thenDs` \ src_loc ->
let
- full_msg = file ++ "|" ++ line ++ "|" ++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])
+ mkStringLit full_msg `thenDs` \ core_msg ->
+ returnDs (mkApps (Var err_id) [(Type . unUsgTy) ty, core_msg])
+ -- unUsgTy *required* -- KSW 1999-04-07
+
+mkStringLit :: String -> DsM CoreExpr
+mkStringLit str = mkStringLitFS (_PK_ str)
+
+mkStringLitFS :: FAST_STRING -> DsM CoreExpr
+mkStringLitFS str
+ | all safeChar chars
+ =
+ dsLookupGlobalValue unpackCStringIdKey `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr str)))
+
+ | otherwise
+ =
+ dsLookupGlobalValue unpackCStringUtf8IdKey `thenDs` \ unpack_id ->
+ returnDs (App (Var unpack_id) (Lit (MachStr (_PK_ (stringToUtf8 chars)))))
+
+ where
+ chars = _UNPK_INT_ str
+ safeChar c = c >= 1 && c <= 0xFF
\end{code}
%************************************************************************
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 :: TypecheckedPat -- 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
-
- is_simple_tuple_pat (TuplePat ps) = all is_var_pat ps
- is_simple_tuple_pat other = False
+mkSelectorBinds (VarPat v) val_expr
+ = returnDs [(v, val_expr)]
- is_var_pat (VarPat v) = True
- is_var_pat other = False -- Even wild-card patterns aren't acceptable
-\end{code}
+mkSelectorBinds pat val_expr
+ | length binders == 1 || is_simple_pat pat
+ = newSysLocalDs (exprType val_expr) `thenDs` \ val_var ->
-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
- 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}
-
-\begin{code}
-mkTupleBind :: [TyVar] -- Abstract wrt these...
- -> [DictVar] -- ... and these
-
- -> [(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
-
- -> CoreExpr -- Expr whose value is a tuple; the expression
- -- may mention the tyvars and dicts
-
- -> DsM [(Id, CoreExpr)] -- Bindings for the globals
-\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}
+ -- 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
+ mkStringLit full_msg `thenDs` \ core_msg ->
+ mapDs (mk_bind val_var msg_var) binders `thenDs` \ binds ->
+ returnDs ( (val_var, val_expr) :
+ (msg_var, core_msg) :
+ binds )
-The general case:
-\begin{code}
-mkTupleBind tyvars dicts local_global_prs 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
- )
+ | 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_tup_bind binder =
+ (binder, mkTupleSelector binders binder tuple_var (Var tuple_var))
+ in
+ returnDs ( (tuple_var, tuple_expr) : map mk_tup_bind binders )
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
- = case (quantifyTy tyvars (mkRhoTy theta
- (applyTyCon (mkTupleTyCon no_of_binders)
- (map idType locals)))) of
- (_{-tossed templates-}, ty) -> ty
+ 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
- theta = map (splitDictType . idType) dicts
-
- mk_selector :: CoreExpr -> (Id, Id) -> Int -> DsM (Id, CoreExpr)
-
- 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 (mkApp_XX (mkCoTyApps tuple_var_expr tyvar_tys) dicts)
- binders selected)
- )
-
-mkApp_XX :: CoreExpr -> [Id] -> CoreExpr
-mkApp_XX expr [] = expr
-mkApp_XX expr (id:ids) = mkApp_XX (App expr (VarArg id)) ids
+ binder_ty = idType bndr_var
+ error_expr = mkApps (Var iRREFUT_PAT_ERROR_ID) [Type binder_ty, Var msg_var]
+
+ is_simple_pat (TuplePat ps 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 (mkTupleCon 0) []
+mkTupleExpr [] = Var unitDataConId
mkTupleExpr [id] = Var id
-mkTupleExpr ids = mkCon (mkTupleCon (length ids))
- [{-usages-}]
- (map idType ids)
- [ VarArg i | i <- ids ]
+mkTupleExpr ids = mkConApp (tupleCon Boxed (length ids))
+ (map (Type . unUsgTy . idType) ids ++ [ Var i | i <- ids ])
\end{code}
just the identity.
\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 expr [var] should_be_the_same_var
+mkTupleSelector [var] should_be_the_same_var scrut_var scrut
= ASSERT(var == should_be_the_same_var)
- expr
+ scrut
+
+mkTupleSelector vars the_var scrut_var scrut
+ = ASSERT( not (null vars) )
+ Case scrut scrut_var [(DataAlt (tupleCon Boxed (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.
-mkTupleSelector expr vars the_var
- = Case expr (AlgAlts [(mkTupleCon arity, vars, Var the_var)]
- NoDefault)
- where
- arity = length vars
+\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}
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
only boxed types can be let-bound, we just turn the fail into a function
for the primitive case:
\begin{verbatim}
- let fail.33 :: () -> Int#
+ let fail.33 :: Void -> Int#
fail.33 = \_ -> error "Help"
in
case x of
p1 -> ...
- p2 -> fail.33 ()
- p3 -> fail.33 ()
+ p2 -> fail.33 void
+ p3 -> fail.33 void
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 (mkFunTys [unit_ty] ty) `thenDs` \ fail_fun_var ->
- newSysLocalDs unit_ty `thenDs` \ fail_fun_arg ->
- returnDs (\ body ->
- NonRec fail_fun_var (Lam (ValBinder fail_fun_arg) body),
- App (Var fail_fun_var) (VarArg unit_id))
+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}
+
-unit_id :: Id -- out here to avoid CAF (sigh)
-unit_id = mkTupleCon 0
-unit_ty :: Type
-unit_ty = idType unit_id
-\end{code}
projects / ghc-hetmet.git / blobdiff