X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2FdeSugar%2FDsUtils.lhs;h=671697b2591e4e6e840901627efa8f9a1194bb10;hb=6d36af4aff6e12afa50dae2fad3993c385f8081d;hp=270c896471fe7eda3b62080292353ea314808399;hpb=d069cec2bd92d4156aeab80f7eb1f222a82e4103;p=ghc-hetmet.git diff --git a/ghc/compiler/deSugar/DsUtils.lhs b/ghc/compiler/deSugar/DsUtils.lhs index 270c896..671697b 100644 --- a/ghc/compiler/deSugar/DsUtils.lhs +++ b/ghc/compiler/deSugar/DsUtils.lhs @@ -7,102 +7,105 @@ This module exports some utility functions of no great interest. \begin{code} module DsUtils ( - CanItFail(..), EquationInfo(..), MatchResult(..), - EqnNo, EqnSet, - - tidyLitPat, tidyNPat, + EquationInfo(..), + firstPat, shiftEqns, mkDsLet, mkDsLets, - cantFailMatchResult, extractMatchResult, - combineMatchResults, - adjustMatchResult, adjustMatchResultDs, - mkCoLetsMatchResult, mkGuardedMatchResult, + MatchResult(..), CanItFail(..), + cantFailMatchResult, alwaysFailMatchResult, + extractMatchResult, combineMatchResults, + adjustMatchResult, adjustMatchResultDs, + mkCoLetMatchResult, + mkGuardedMatchResult, mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, + wrapBind, wrapBinds, - mkErrorAppDs, mkNilExpr, mkConsExpr, - mkStringLit, mkStringLitFS, mkIntegerLit, + mkErrorAppDs, mkNilExpr, mkConsExpr, mkListExpr, + mkIntExpr, mkCharExpr, + mkStringExpr, mkStringExprFS, mkIntegerExpr, - mkSelectorBinds, mkTupleExpr, mkTupleSelector, + mkSelectorBinds, mkTupleExpr, mkTupleSelector, + mkTupleType, mkTupleCase, mkBigCoreTup, + mkCoreTup, mkCoreTupTy, + + dsReboundNames, lookupReboundName, - selectMatchVar + selectSimpleMatchVarL, selectMatchVars ) where #include "HsVersions.h" -import {-# SOURCE #-} Match ( matchSimply ) +import {-# SOURCE #-} Match ( matchSimply ) +import {-# SOURCE #-} DsExpr( dsExpr ) import HsSyn -import TcHsSyn ( TypecheckedPat ) -import DsHsSyn ( outPatType, collectTypedPatBinders ) +import TcHsSyn ( hsPatType ) import CoreSyn - +import Constants ( mAX_TUPLE_SIZE ) import DsMonad -import CoreUtils ( exprType, mkIfThenElse ) -import PrelInfo ( iRREFUT_PAT_ERROR_ID ) -import MkId ( rebuildConArgs ) -import Id ( idType, Id, mkWildId ) -import Literal ( Literal(..), inIntRange, tARGET_MAX_INT ) -import TyCon ( isNewTyCon, tyConDataCons, isRecursiveTyCon ) -import DataCon ( DataCon, dataConStrictMarks, dataConId ) -import TcType ( mkFunTy, isUnLiftedType, Type ) -import TcType ( tcSplitTyConApp, isIntTy, isFloatTy, isDoubleTy ) -import TysPrim ( intPrimTy, charPrimTy, floatPrimTy, doublePrimTy ) +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, + tupleCon, mkTupleTy, unitDataConId, unitTy, charTy, charDataCon, - intDataCon, smallIntegerDataCon, - floatDataCon, - doubleDataCon, - stringTy - ) + intTy, intDataCon, + isPArrFakeCon ) import BasicTypes ( Boxity(..) ) -import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet, UniqSet ) +import UniqSet ( mkUniqSet, minusUniqSet, isEmptyUniqSet ) +import UniqSupply ( splitUniqSupply, uniqFromSupply, uniqsFromSupply ) import PrelNames ( unpackCStringName, unpackCStringUtf8Name, - plusIntegerName, timesIntegerName ) + plusIntegerName, timesIntegerName, smallIntegerDataConName, + lengthPName, indexPName ) import Outputable -import UnicodeUtil ( stringToUtf8 ) +import UnicodeUtil ( intsToUtf8 ) +import SrcLoc ( Located(..), unLoc ) +import Util ( isSingleton, notNull, zipEqual, sortWith ) +import ListSetOps ( assocDefault ) +import FastString \end{code} %************************************************************************ %* * -\subsection{Tidying lit pats} + Rebindable syntax %* * %************************************************************************ \begin{code} -tidyLitPat :: HsLit -> TypecheckedPat -> TypecheckedPat -tidyLitPat (HsChar c) pat = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) charPrimTy] -tidyLitPat lit pat = pat - -tidyNPat :: HsLit -> Type -> TypecheckedPat -> TypecheckedPat -tidyNPat (HsString s) _ pat - | _LENGTH_ s <= 1 -- Short string literals only - = foldr (\c pat -> ConPat consDataCon stringTy [] [] [mk_char_lit c,pat]) - (ConPat nilDataCon stringTy [] [] []) (_UNPK_INT_ s) - -- The stringTy is the type of the whole pattern, not - -- the type to instantiate (:) or [] with! - where - mk_char_lit c = ConPat charDataCon charTy [] [] [LitPat (HsCharPrim c) charPrimTy] - -tidyNPat lit lit_ty default_pat - | isIntTy lit_ty = ConPat intDataCon lit_ty [] [] [LitPat (mk_int lit) intPrimTy] - | isFloatTy lit_ty = ConPat floatDataCon lit_ty [] [] [LitPat (mk_float lit) floatPrimTy] - | isDoubleTy lit_ty = ConPat doubleDataCon lit_ty [] [] [LitPat (mk_double lit) doublePrimTy] - | otherwise = default_pat +dsReboundNames :: ReboundNames Id + -> DsM ([CoreBind], -- Auxiliary bindings + [(Name,Id)]) -- Maps the standard name to its value +dsReboundNames rebound_ids + = mapAndUnzipDs mk_bind rebound_ids `thenDs` \ (binds_s, prs) -> + return (concat binds_s, prs) where - mk_int (HsInteger i) = HsIntPrim i - - mk_float (HsInteger i) = HsFloatPrim (fromInteger i) - mk_float (HsRat f _) = HsFloatPrim f - - mk_double (HsInteger i) = HsDoublePrim (fromInteger i) - mk_double (HsRat f _) = HsDoublePrim f + -- The cheapo special case can happen when we + -- make an intermediate HsDo when desugaring a RecStmt + mk_bind (std_name, HsVar id) = return ([], (std_name, id)) + mk_bind (std_name, expr) + = dsExpr expr `thenDs` \ rhs -> + newSysLocalDs (exprType rhs) `thenDs` \ id -> + return ([NonRec id rhs], (std_name, id)) + +lookupReboundName :: [(Name,Id)] -> Name -> CoreExpr +lookupReboundName prs std_name + = Var (assocDefault (mk_panic std_name) prs std_name) + where + mk_panic std_name = pprPanic "dsReboundNames" (ptext SLIT("Not found:") <+> ppr std_name) \end{code} @@ -118,7 +121,8 @@ back again. \begin{code} mkDsLet :: CoreBind -> CoreExpr -> CoreExpr mkDsLet (NonRec bndr rhs) body - | isUnLiftedType (idType bndr) = Case rhs bndr [(DEFAULT,[],body)] + | isUnLiftedType (idType bndr) + = Case rhs bndr (exprType body) [(DEFAULT,[],body)] mkDsLet bind body = Let bind body @@ -139,11 +143,36 @@ hand, which should indeed be bound to the pattern as a whole, then use it; otherwise, make one up. \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... +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} @@ -158,42 +187,20 @@ The ``equation info'' used by @match@ is relatively complicated and worthy of a type synonym and a few handy functions. \begin{code} +firstPat :: EquationInfo -> Pat Id +firstPat eqn = head (eqn_pats eqn) -type EqnNo = Int -type EqnSet = UniqSet EqnNo - -data EquationInfo - = EqnInfo - 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 -- 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! - -data CanItFail = CanFail | CantFail - -orFail CantFail CantFail = CantFail -orFail _ _ = CanFail +shiftEqns :: [EquationInfo] -> [EquationInfo] +-- Drop the first pattern in each equation +shiftEqns eqns = [ eqn { eqn_pats = tail (eqn_pats eqn) } | eqn <- eqns ] \end{code} Functions on MatchResults \begin{code} +alwaysFailMatchResult :: MatchResult +alwaysFailMatchResult = MatchResult CanFail (\fail -> returnDs fail) + cantFailMatchResult :: CoreExpr -> MatchResult cantFailMatchResult expr = MatchResult CantFail (\ ignore -> returnDs expr) @@ -220,7 +227,6 @@ combineMatchResults (MatchResult CanFail body_fn1) 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 -> @@ -231,11 +237,19 @@ 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) -mkCoLetsMatchResult :: [CoreBind] -> MatchResult -> MatchResult -mkCoLetsMatchResult binds match_result - = adjustMatchResult (mkDsLets binds) match_result +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) @@ -243,48 +257,48 @@ mkGuardedMatchResult pred_expr (MatchResult can_it_fail body_fn) returnDs (mkIfThenElse pred_expr body fail)) mkCoPrimCaseMatchResult :: Id -- Scrutinee + -> Type -- Type of the case -> [(Literal, MatchResult)] -- Alternatives -> MatchResult -mkCoPrimCaseMatchResult var match_alts +mkCoPrimCaseMatchResult var ty match_alts = MatchResult CanFail mk_case where mk_case fail - = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> - returnDs (Case (Var var) var ((DEFAULT, [], fail) : alts)) + = mappM (mk_alt fail) sorted_alts `thenDs` \ alts -> + returnDs (Case (Var var) var ty ((DEFAULT, [], fail) : alts)) + sorted_alts = sortWith fst match_alts -- Right order for a Case mk_alt fail (lit, MatchResult _ body_fn) = body_fn fail `thenDs` \ body -> returnDs (LitAlt lit, [], body) mkCoAlgCaseMatchResult :: Id -- Scrutinee + -> Type -- Type of exp -> [(DataCon, [CoreBndr], MatchResult)] -- Alternatives -> MatchResult - -mkCoAlgCaseMatchResult var match_alts +mkCoAlgCaseMatchResult var ty match_alts | isNewTyCon tycon -- Newtype case; use a let - = ASSERT( null (tail match_alts) && null (tail arg_ids) ) - mkCoLetsMatchResult [NonRec arg_id newtype_rhs] match_result + = 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 | otherwise -- Datatype case; use a case = MatchResult fail_flag mk_case where - -- Common stuff - scrut_ty = idType var - (tycon, _) = tcSplitTyConApp scrut_ty -- Newtypes must be opaque here + 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 - (_, arg_ids, match_result) = head match_alts - arg_id = head arg_ids - - newtype_rhs | isRecursiveTyCon tycon -- Recursive case; need a case - = Note (Coerce (idType arg_id) scrut_ty) (Var var) - | otherwise -- Normal case (newtype is transparent) - = Var var + (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] + 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] @@ -292,16 +306,15 @@ mkCoAlgCaseMatchResult var match_alts = CanFail wild_var = mkWildId (idType var) - mk_case fail = mapDs (mk_alt fail) match_alts `thenDs` \ alts -> - returnDs (Case (Var var) wild_var (mk_default fail ++ alts)) + 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 -> - getUniquesDs `thenDs` \ us -> - let - (binds, real_args) = rebuildConArgs args (dataConStrictMarks con) us - in - returnDs (DataAlt con, real_args, mkDsLets binds body) + = body_fn fail `thenDs` \ body -> + newUniqueSupply `thenDs` \ us -> + returnDs (mkReboxingAlt (uniqsFromSupply us) con args body) mk_default fail | exhaustive_case = [] | otherwise = [(DEFAULT, [], fail)] @@ -309,6 +322,71 @@ mkCoAlgCaseMatchResult var match_alts 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} @@ -325,11 +403,11 @@ mkErrorAppDs :: Id -- The error function -> DsM CoreExpr mkErrorAppDs err_id ty msg - = getSrcLocDs `thenDs` \ src_loc -> + = getSrcSpanDs `thenDs` \ src_loc -> let full_msg = showSDoc (hcat [ppr src_loc, text "|", text msg]) + core_msg = Lit (mkStringLit full_msg) in - mkStringLit full_msg `thenDs` \ core_msg -> returnDs (mkApps (Var err_id) [Type ty, core_msg]) \end{code} @@ -341,61 +419,70 @@ mkErrorAppDs err_id ty msg %************************************************************************ \begin{code} -mkIntegerLit :: Integer -> DsM CoreExpr -mkIntegerLit i +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 - = returnDs (mkSmallIntegerLit i) + = 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 - = dsLookupGlobalValue plusIntegerName `thenDs` \ plus_id -> - dsLookupGlobalValue timesIntegerName `thenDs` \ times_id -> + = 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 mkSmallIntegerLit i - else mkSmallIntegerLit r `plus` mkSmallIntegerLit (i-r) - | r == 0 = horner b q `times` mkSmallIntegerLit b - | otherwise = mkSmallIntegerLit r `plus` (horner b q `times` mkSmallIntegerLit b) + then lit i + else lit r `plus` lit (i-r) + | r == 0 = horner b q `times` lit b + | otherwise = lit r `plus` (horner b q `times` lit b) where (q,r) = i `quotRem` b in returnDs (horner tARGET_MAX_INT i) -mkSmallIntegerLit i = mkConApp smallIntegerDataCon [mkIntLit i] +mkSmallIntegerLit small_integer_data_con i = mkConApp small_integer_data_con [mkIntLit i] -mkStringLit :: String -> DsM CoreExpr -mkStringLit str = mkStringLitFS (_PK_ str) +mkStringExpr str = mkStringExprFS (mkFastString str) -mkStringLitFS :: FAST_STRING -> DsM CoreExpr -mkStringLitFS str - | _NULL_ str +mkStringExprFS str + | nullFastString str = returnDs (mkNilExpr charTy) - | _LENGTH_ str == 1 + | lengthFS str == 1 = let - the_char = mkConApp charDataCon [mkLit (MachChar (_HEAD_INT_ str))] + the_char = mkCharExpr (headFS str) in returnDs (mkConsExpr charTy the_char (mkNilExpr charTy)) - | all safeChar chars - = dsLookupGlobalValue unpackCStringName `thenDs` \ unpack_id -> + | all safeChar int_chars + = dsLookupGlobalId unpackCStringName `thenDs` \ unpack_id -> returnDs (App (Var unpack_id) (Lit (MachStr str))) | otherwise - = dsLookupGlobalValue unpackCStringUtf8Name `thenDs` \ unpack_id -> - returnDs (App (Var unpack_id) (Lit (MachStr (_PK_ (stringToUtf8 chars))))) + = dsLookupGlobalId unpackCStringUtf8Name `thenDs` \ unpack_id -> + returnDs (App (Var unpack_id) (Lit (MachStr (mkFastString (intsToUtf8 int_chars))))) where - chars = _UNPK_INT_ str + int_chars = unpackIntFS str safeChar c = c >= 1 && c <= 0xFF \end{code} @@ -423,81 +510,132 @@ even more helpful. Something very similar happens for pattern-bound expressions. \begin{code} -mkSelectorBinds :: TypecheckedPat -- 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 (VarPat v) val_expr +mkSelectorBinds (L _ (VarPat v)) val_expr = returnDs [(v, val_expr)] mkSelectorBinds pat val_expr - | 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 - mkStringLit full_msg `thenDs` \ core_msg -> - mapDs (mk_bind val_var msg_var) binders `thenDs` \ binds -> + | 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) : - (msg_var, core_msg) : + (err_var, err_expr) : binds ) | otherwise - = mkErrorAppDs iRREFUT_PAT_ERROR_ID tuple_ty (showSDoc (ppr pat)) - `thenDs` \ error_expr -> - matchSimply val_expr PatBindRhs pat local_tuple error_expr - `thenDs` \ tuple_expr -> - newSysLocalDs tuple_ty - `thenDs` \ tuple_var -> + = 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)) + 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 - binders = collectTypedPatBinders pat + binders = collectPatBinders 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 } + 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 - binder_ty = idType bndr_var - error_expr = mkApps (Var iRREFUT_PAT_ERROR_ID) [Type binder_ty, Var msg_var] + error_expr = mkCoerce (idType bndr_var) (Var err_var) + + is_simple_lpat p = is_simple_pat (unLoc p) + + is_simple_pat (TuplePat ps Boxed) = all is_triv_lpat ps + is_simple_pat (ConPatOut _ _ _ _ ps _) = all is_triv_lpat (hsConArgs ps) + is_simple_pat (VarPat _) = True + is_simple_pat (ParPat p) = is_simple_lpat p + is_simple_pat other = False - is_simple_pat (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_lpat p = is_triv_pat (unLoc p) 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} -@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. If it -has only one element, it is the identity function. +%************************************************************************ +%* * + Tuples +%* * +%************************************************************************ + +@mkTupleExpr@ builds a tuple; the inverse to @mkTupleSelector@. + +* 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. \begin{code} mkTupleExpr :: [Id] -> CoreExpr +mkTupleExpr ids = mkBigCoreTup (map Var ids) -mkTupleExpr [] = Var unitDataConId -mkTupleExpr [id] = Var id -mkTupleExpr ids = mkConApp (tupleCon Boxed (length ids)) - (map (Type . idType) ids ++ [ Var i | i <- ids ]) +-- corresponding type +mkTupleType :: [Id] -> Type +mkTupleType ids = mkBigTuple mkCoreTupTy (map idType ids) + +mkBigCoreTup :: [CoreExpr] -> CoreExpr +mkBigCoreTup = mkBigTuple mkCoreTup + +mkBigTuple :: ([a] -> a) -> [a] -> a +mkBigTuple small_tuple as = mk_big_tuple (chunkify as) + where + -- Each sub-list is short enough to fit in a tuple + mk_big_tuple [as] = small_tuple as + mk_big_tuple as_s = mk_big_tuple (chunkify (map small_tuple as_s)) + +chunkify :: [a] -> [[a]] +-- The sub-lists of the result all have length <= mAX_TUPLE_SIZE +-- But there may be more than mAX_TUPLE_SIZE sub-lists +chunkify xs + | n_xs <= mAX_TUPLE_SIZE = {- pprTrace "Small" (ppr n_xs) -} [xs] + | otherwise = {- pprTrace "Big" (ppr n_xs) -} (split xs) + where + n_xs = length xs + split [] = [] + split xs = take mAX_TUPLE_SIZE xs : split (drop mAX_TUPLE_SIZE xs) \end{code} @@ -510,6 +648,19 @@ 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 :: [Id] -- The tuple args -> Id -- The selected one @@ -517,15 +668,78 @@ mkTupleSelector :: [Id] -- The tuple args -> CoreExpr -- Scrutinee -> CoreExpr -mkTupleSelector [var] should_be_the_same_var scrut_var scrut - = ASSERT(var == should_be_the_same_var) - 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)] + = mk_tup_sel (chunkify vars) the_var + where + mk_tup_sel [vars] the_var = mkCoreSel vars the_var scrut_var scrut + mk_tup_sel vars_s the_var = mkCoreSel group the_var tpl_v $ + mk_tup_sel (chunkify tpl_vs) tpl_v + where + tpl_tys = [mkCoreTupTy (map idType gp) | gp <- vars_s] + tpl_vs = mkTemplateLocals tpl_tys + [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s, + the_var `elem` gp ] +\end{code} + +A generalization of @mkTupleSelector@, allowing the body +of the case to be an arbitrary expression. + +If the tuple is big, it is nested: + + mkTupleCase uniqs [a,b,c,d] body v e + = case e of v { (p,q) -> + case p of p { (a,b) -> + case q of q { (c,d) -> + body }}} + +To avoid shadowing, we use uniqs to invent new variables p,q. + +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} %************************************************************************ %* * @@ -538,10 +752,44 @@ interact well with rules. \begin{code} mkNilExpr :: Type -> CoreExpr -mkNilExpr ty = App (Var (dataConId nilDataCon)) (Type ty) +mkNilExpr ty = mkConApp nilDataCon [Type ty] mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr -mkConsExpr ty hd tl = mkApps (Var (dataConId consDataCon)) [Type ty, hd, tl] +mkConsExpr ty hd tl = mkConApp consDataCon [Type ty, hd, tl] + +mkListExpr :: Type -> [CoreExpr] -> CoreExpr +mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs + + +-- The next three functions make tuple types, constructors and selectors, +-- with the rule that a 1-tuple is represented by the thing itselg +mkCoreTupTy :: [Type] -> Type +mkCoreTupTy [ty] = ty +mkCoreTupTy tys = mkTupleTy Boxed (length tys) tys + +mkCoreTup :: [CoreExpr] -> CoreExpr +-- Builds exactly the specified tuple. +-- No fancy business for big tuples +mkCoreTup [] = Var unitDataConId +mkCoreTup [c] = c +mkCoreTup cs = mkConApp (tupleCon Boxed (length cs)) + (map (Type . exprType) cs ++ cs) + +mkCoreSel :: [Id] -- The tuple args + -> Id -- The selected one + -> Id -- A variable of the same type as the scrutinee + -> CoreExpr -- Scrutinee + -> CoreExpr +-- mkCoreSel [x,y,z] x v e +-- ===> case e of v { (x,y,z) -> x +mkCoreSel [var] should_be_the_same_var scrut_var scrut + = ASSERT(var == should_be_the_same_var) + scrut + +mkCoreSel vars the_var scrut_var scrut + = ASSERT( notNull vars ) + Case scrut scrut_var (idType the_var) + [(DataAlt (tupleCon Boxed (length vars)), vars, Var the_var)] \end{code} @@ -620,4 +868,3 @@ mkFailurePair expr \end{code} -