X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FdeSugar%2FDsUtils.lhs;h=70944f81591b24ff0acf836754702afa72de9a03;hb=04feba252e40d16101b92948cd1e13c7bc1f3062;hp=07cbe0b249279e78b7049369e09e04a2da175679;hpb=0596517a9b4b2b32e5d375a986351102ac4540fc;p=ghc-hetmet.git diff --git a/ghc/compiler/deSugar/DsUtils.lhs b/ghc/compiler/deSugar/DsUtils.lhs index 07cbe0b..70944f8 100644 --- a/ghc/compiler/deSugar/DsUtils.lhs +++ b/ghc/compiler/deSugar/DsUtils.lhs @@ -1,58 +1,185 @@ % -% (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, - mkCoAlgCaseMatchResult, - mkAppDs, mkConDs, mkPrimDs, - mkCoLetsMatchResult, - mkCoPrimCaseMatchResult, - mkFailurePair, - mkGuardedMatchResult, - mkSelectorBinds, - mkTupleBind, - mkTupleExpr, - selectMatchVars + EquationInfo(..), + firstPat, shiftEqns, + + mkDsLet, mkDsLets, + + MatchResult(..), CanItFail(..), + cantFailMatchResult, alwaysFailMatchResult, + extractMatchResult, combineMatchResults, + adjustMatchResult, adjustMatchResultDs, + mkCoLetMatchResult, mkGuardedMatchResult, + matchCanFail, + mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, + wrapBind, wrapBinds, + + mkErrorAppDs, mkNilExpr, mkConsExpr, mkListExpr, + mkIntExpr, mkCharExpr, + mkStringExpr, mkStringExprFS, mkIntegerExpr, + + mkSelectorBinds, mkTupleExpr, mkTupleSelector, + mkTupleType, mkTupleCase, mkBigCoreTup, + mkCoreTup, mkCoreTupTy, + + dsSyntaxTable, lookupEvidence, + + selectSimpleMatchVarL, selectMatchVars ) where -import Ubiq -import DsLoop ( match, matchSimply ) +#include "HsVersions.h" -import HsSyn ( HsExpr(..), OutPat(..), HsLit(..), - Match, HsBinds, Stmt, Qual, PolyType, ArithSeqInfo ) -import TcHsSyn ( 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, escErrorMsg, mkCoreIfThenElse, mkErrorApp ) -import PrelInfo ( stringTy ) -import Id ( idType, getInstantiatedDataConSig, mkTupleCon, - DataCon(..), DictVar(..), Id(..), GenId ) -import TyCon ( mkTupleTyCon ) -import Type ( mkTyVarTys, mkRhoTy, mkFunTys, - applyTyCon, getAppDataTyCon ) -import UniqSet ( mkUniqSet, minusUniqSet, uniqSetToList, UniqSet(..) ) -import Util ( panic, assertPanic ) - -isUnboxedDataType = panic "DsUtils.isUnboxedDataType" -quantifyTy = panic "DsUtils.quantifyTy" -splitDictType = panic "DsUtils.splitDictType" -mkCoTyApps = panic "DsUtils.mkCoTyApps" +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 SrcLoc ( Located(..), unLoc ) +import Util ( isSingleton, zipEqual, sortWith ) +import ListSetOps ( assocDefault ) +import FastString +import Data.Char ( ord ) + +#ifdef DEBUG +import Util ( notNull ) -- Used in an assertion +#endif +\end{code} + + + +%************************************************************************ +%* * + Rebindable syntax +%* * +%************************************************************************ + +\begin{code} +dsSyntaxTable :: SyntaxTable Id + -> DsM ([CoreBind], -- Auxiliary bindings + [(Name,Id)]) -- Maps the standard name to its value + +dsSyntaxTable rebound_ids + = mapAndUnzipDs mk_bind rebound_ids `thenDs` \ (binds_s, prs) -> + 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)) + +lookupEvidence :: [(Name, Id)] -> Name -> Id +lookupEvidence prs std_name + = assocDefault (mk_panic std_name) prs std_name + where + mk_panic std_name = pprPanic "dsSyntaxTable" (ptext SLIT("Not found:") <+> ppr std_name) +\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 * @@ -64,214 +191,311 @@ The ``equation info'' used by @match@ is relatively complicated and 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} +firstPat :: EquationInfo -> Pat Id +firstPat eqn = head (eqn_pats eqn) -\begin{code} -data MatchResult - = MatchResult - CanItFail - Type -- Type of argument expression +shiftEqns :: [EquationInfo] -> [EquationInfo] +-- Drop the first pattern in each equation +shiftEqns eqns = [ eqn { eqn_pats = tail (eqn_pats eqn) } | eqn <- eqns ] +\end{code} - (CoreExpr -> CoreExpr) - -- Takes a expression to plug in at the - -- failure point(s). The expression should - -- be duplicatable! +Functions on MatchResults - 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! +\begin{code} +matchCanFail :: MatchResult -> Bool +matchCanFail (MatchResult CanFail _) = True +matchCanFail (MatchResult CantFail _) = False -data CanItFail = CanFail | CantFail +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 - = -- 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,_) = getInstantiatedDataConSig 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 - scrut_ty = idType var - (tycon, tycon_arg_tys, data_cons) = getAppDataTyCon scrut_ty + mk_case fail + = mappM (mk_alt fail) sorted_alts `thenDs` \ alts -> + returnDs (Case (Var var) var ty ((DEFAULT, [], fail) : alts)) - un_mentioned_constructors - = uniqSetToList (mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- alts] ) + sorted_alts = sortWith fst match_alts -- Right order for a Case + mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body -> + returnDs (LitAlt lit, [], body) - 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 - ] - - -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) -combineMatchResults match_result1@(MatchResult CantFail ty body_fn1 cxt1) - match_result2 - = returnDs match_result1 +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 + | isPArrFakeAlts match_alts -- Sugared parallel array; use a literal case + = MatchResult CanFail mk_parrCase --- 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) + | 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] + + fail_flag | exhaustive_case + = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results] + | otherwise + = CanFail + + wild_var = mkWildId (idType var) + sorted_alts = sortWith get_tag match_alts + get_tag (con, _, _) = dataConTag con + mk_case fail = mappM (mk_alt fail) sorted_alts `thenDs` \ alts -> + returnDs (Case (Var var) wild_var ty (mk_default fail ++ alts)) + + mk_alt fail (con, args, MatchResult _ body_fn) + = body_fn fail `thenDs` \ body -> + newUniqueSupply `thenDs` \ us -> + returnDs (mkReboxingAlt (uniqsFromSupply us) con args body) + + 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 :: 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 +mkErrorAppDs :: Id -- The error function + -> Type -- Type to which it should be applied + -> String -- The error message string to pass + -> DsM CoreExpr -dsExprToAtom (Var v) continue_with = continue_with (VarArg v) -dsExprToAtom (Lit v) continue_with = continue_with (LitArg v) - -dsExprToAtom 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) + -- mkStringLit returns a result of type String# in - newSysLocalDs ty `thenDs` \ arg_id -> - continue_with (VarArg arg_id) `thenDs` \ body -> - returnDs ( - if isUnboxedDataType 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) + returnDs (mkApps (Var err_id) [Type ty, core_msg]) \end{code} -%************************************************************************ + +************************************************************* %* * -\subsection{Desugarer's versions of some Core functions} +\subsection{Making literals} %* * %************************************************************************ -Plumb the desugarer's @UniqueSupply@ in/out of the @UniqSupply@ monad -world. \begin{code} -mkAppDs :: CoreExpr -> [Type] -> [CoreExpr] -> DsM CoreExpr -mkConDs :: Id -> [Type] -> [CoreExpr] -> DsM CoreExpr -mkPrimDs :: PrimOp -> [Type] -> [CoreExpr] -> DsM CoreExpr +mkCharExpr :: Char -> CoreExpr -- Returns C# c :: Int +mkIntExpr :: Integer -> CoreExpr -- Returns I# i :: Int +mkIntegerExpr :: Integer -> DsM CoreExpr -- Result :: Integer +mkStringExpr :: String -> DsM CoreExpr -- Result :: String +mkStringExprFS :: FastString -> DsM CoreExpr -- Result :: String + +mkIntExpr i = mkConApp intDataCon [mkIntLit i] +mkCharExpr c = mkConApp charDataCon [mkLit (MachChar c)] + +mkIntegerExpr i + | inIntRange i -- Small enough, so start from an Int + = dsLookupDataCon smallIntegerDataConName `thenDs` \ integer_dc -> + returnDs (mkSmallIntegerLit integer_dc i) + +-- Special case for integral literals with a large magnitude: +-- They are transformed into an expression involving only smaller +-- integral literals. This improves constant folding. + + | otherwise -- Big, so start from a string + = dsLookupGlobalId plusIntegerName `thenDs` \ plus_id -> + dsLookupGlobalId timesIntegerName `thenDs` \ times_id -> + dsLookupDataCon smallIntegerDataConName `thenDs` \ integer_dc -> + let + lit i = mkSmallIntegerLit integer_dc i + plus a b = Var plus_id `App` a `App` b + times a b = Var times_id `App` a `App` b + + -- Transform i into (x1 + (x2 + (x3 + (...) * b) * b) * b) with abs xi <= b + horner :: Integer -> Integer -> CoreExpr + horner b i | abs q <= 1 = if r == 0 || r == i + then lit i + else lit r `plus` lit (i-r) + | r == 0 = horner b q `times` lit b + | otherwise = lit r `plus` (horner b q `times` lit b) + where + (q,r) = i `quotRem` b + + in + returnDs (horner tARGET_MAX_INT i) -mkAppDs fun tys arg_exprs - = dsExprsToAtoms arg_exprs $ \ vals -> - returnDs (mkApp fun [] tys vals) +mkSmallIntegerLit small_integer_data_con i = mkConApp small_integer_data_con [mkIntLit i] -mkConDs con tys arg_exprs - = dsExprsToAtoms arg_exprs $ \ vals -> - returnDs (mkCon con [] tys vals) +mkStringExpr str = mkStringExprFS (mkFastString str) -mkPrimDs op tys arg_exprs - = dsExprsToAtoms arg_exprs $ \ vals -> - returnDs (mkPrim op [] tys vals) +mkStringExprFS str + | nullFS str + = returnDs (mkNilExpr charTy) + + | lengthFS str == 1 + = let + the_char = mkCharExpr (headFS str) + in + returnDs (mkConsExpr charTy the_char (mkNilExpr charTy)) + + | all safeChar chars + = dsLookupGlobalId unpackCStringName `thenDs` \ unpack_id -> + returnDs (App (Var unpack_id) (Lit (MachStr str))) + + | otherwise + = dsLookupGlobalId unpackCStringUtf8Name `thenDs` \ unpack_id -> + returnDs (App (Var unpack_id) (Lit (MachStr str))) + + where + chars = unpackFS str + safeChar c = ord c >= 1 && ord c <= 0x7F \end{code} + %************************************************************************ %* * \subsection[mkSelectorBind]{Make a selector bind} @@ -280,10 +504,10 @@ mkPrimDs op tys arg_exprs 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 @@ -295,154 +519,132 @@ even more helpful. Something very similar happens for pattern-bound 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 - = getSrcLocDs `thenDs` \ (src_file, src_line) -> - - if is_simple_tuple_pat pat then - mkTupleBind tyvars [] locals_and_globals val_expr - else - newSysLocalDs stringTy `thenDs` \ str_var -> -- to hold the string - let - src_loc_str = escErrorMsg ('"' : src_file) ++ "%l" ++ src_line - error_string = src_loc_str ++ "%~" --> ": pattern-match failed on an irrefutable pattern" - error_msg = mkErrorApp res_ty str_var error_string - in - 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} - -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 - ) - 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 - where - theta = map (splitDictType . idType) dicts +%************************************************************************ +%* * + Tuples +%* * +%************************************************************************ - mk_selector :: CoreExpr -> (Id, Id) -> Int -> DsM (Id, CoreExpr) +@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. - 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 -\end{code} +* If it has only one element, it is the identity function. +* If there are more elements than a big tuple can have, it nests + the tuples. +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) + +mkBigCoreTup :: [CoreExpr] -> CoreExpr +mkBigCoreTup = mkBigTuple mkCoreTup -mkTupleExpr [] = Con (mkTupleCon 0) [] -mkTupleExpr [id] = Var id -mkTupleExpr ids = mkCon (mkTupleCon (length ids)) - [{-usages-}] - (map idType ids) - [ VarArg i | i <- ids ] +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} @@ -455,23 +657,148 @@ are in scope. If there is just one id in the ``tuple'', then the selector is just the identity. +If it's big, it does nesting + mkTupleSelector [a,b,c,d] b v e + = case e of v { + (p,q) -> case p of p { + (a,b) -> b }} +We use 'tpl' vars for the p,q, since shadowing does not matter. + +In fact, it's more convenient to generate it innermost first, getting + + case (case e of v + (p,q) -> p) of p + (a,b) -> b + \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 }}} -mkTupleSelector expr [var] should_be_the_same_var +To avoid shadowing, we use uniqs to invent new variables p,q. + +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} @@ -495,7 +822,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 +833,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 @@ -517,40 +844,36 @@ which is of course utterly wrong. Rather than drop the condition that 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 - | isUnboxedDataType 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}