2 -- | Handy functions for creating much Core syntax
4 -- * Constructing normal syntax
6 mkCoreApp, mkCoreApps, mkCoreConApps,
7 mkCoreLams, mkWildCase, mkIfThenElse,
8 mkWildValBinder, mkWildEvBinder,
10 -- * Constructing boxed literals
11 mkWordExpr, mkWordExprWord,
12 mkIntExpr, mkIntExprInt,
14 mkFloatExpr, mkDoubleExpr,
15 mkCharExpr, mkStringExpr, mkStringExprFS,
17 -- * Constructing general big tuples
21 -- * Constructing small tuples
22 mkCoreVarTup, mkCoreVarTupTy, mkCoreTup,
24 -- * Constructing big tuples
25 mkBigCoreVarTup, mkBigCoreVarTupTy,
26 mkBigCoreTup, mkBigCoreTupTy,
28 -- * Deconstructing small tuples
29 mkSmallTupleSelector, mkSmallTupleCase,
31 -- * Deconstructing big tuples
32 mkTupleSelector, mkTupleCase,
34 -- * Constructing list expressions
35 mkNilExpr, mkConsExpr, mkListExpr,
36 mkFoldrExpr, mkBuildExpr
39 #include "HsVersions.h"
42 import Var ( EvVar, mkWildCoVar, setTyVarUnique )
45 import CoreUtils ( exprType, needsCaseBinding, bindNonRec )
53 import TysPrim ( alphaTyVar )
54 import DataCon ( DataCon, dataConWorkId )
59 import Unique ( mkBuiltinUnique )
61 import Util ( notNull, zipEqual )
64 import Data.Char ( ord )
67 infixl 4 `mkCoreApp`, `mkCoreApps`
70 %************************************************************************
72 \subsection{Basic CoreSyn construction}
74 %************************************************************************
77 -- | Bind a binding group over an expression, using a @let@ or @case@ as
78 -- appropriate (see "CoreSyn#let_app_invariant")
79 mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr
80 mkCoreLet (NonRec bndr rhs) body -- See Note [CoreSyn let/app invariant]
81 | needsCaseBinding (idType bndr) rhs
82 = Case rhs bndr (exprType body) [(DEFAULT,[],body)]
86 -- | Bind a list of binding groups over an expression. The leftmost binding
87 -- group becomes the outermost group in the resulting expression
88 mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr
89 mkCoreLets binds body = foldr mkCoreLet body binds
91 -- | Construct an expression which represents the application of one expression
93 mkCoreApp :: CoreExpr -> CoreExpr -> CoreExpr
94 -- Check the invariant that the arg of an App is ok-for-speculation if unlifted
95 -- See CoreSyn Note [CoreSyn let/app invariant]
96 mkCoreApp fun (Type ty) = App fun (Type ty)
97 mkCoreApp fun arg = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg )
98 mk_val_app fun arg arg_ty res_ty
100 fun_ty = exprType fun
101 (arg_ty, res_ty) = splitFunTy fun_ty
103 -- | Construct an expression which represents the application of a number of
104 -- expressions to another. The leftmost expression in the list is applied first
105 mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr
106 -- Slightly more efficient version of (foldl mkCoreApp)
107 mkCoreApps orig_fun orig_args
108 = go orig_fun (exprType orig_fun) orig_args
111 go fun fun_ty (Type ty : args) = go (App fun (Type ty)) (applyTy fun_ty ty) args
112 go fun fun_ty (arg : args) = ASSERT2( isFunTy fun_ty, ppr fun_ty $$ ppr orig_fun $$ ppr orig_args )
113 go (mk_val_app fun arg arg_ty res_ty) res_ty args
115 (arg_ty, res_ty) = splitFunTy fun_ty
117 -- | Construct an expression which represents the application of a number of
118 -- expressions to that of a data constructor expression. The leftmost expression
119 -- in the list is applied first
120 mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr
121 mkCoreConApps con args = mkCoreApps (Var (dataConWorkId con)) args
124 mk_val_app :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr
125 mk_val_app fun arg arg_ty _ -- See Note [CoreSyn let/app invariant]
126 | not (needsCaseBinding arg_ty arg)
127 = App fun arg -- The vastly common case
129 mk_val_app fun arg arg_ty res_ty
130 = Case arg arg_id res_ty [(DEFAULT,[],App fun (Var arg_id))]
132 arg_id = mkWildValBinder arg_ty
133 -- Lots of shadowing, but it doesn't matter,
134 -- because 'fun ' should not have a free wild-id
136 -- This is Dangerous. But this is the only place we play this
137 -- game, mk_val_app returns an expression that does not have
138 -- have a free wild-id. So the only thing that can go wrong
139 -- is if you take apart this case expression, and pass a
140 -- fragmet of it as the fun part of a 'mk_val_app'.
142 mkWildEvBinder :: PredType -> EvVar
143 mkWildEvBinder pred@(EqPred {}) = mkWildCoVar (mkPredTy pred)
144 mkWildEvBinder pred = mkWildValBinder (mkPredTy pred)
146 -- | Make a /wildcard binder/. This is typically used when you need a binder
147 -- that you expect to use only at a *binding* site. Do not use it at
148 -- occurrence sites because it has a single, fixed unique, and it's very
149 -- easy to get into difficulties with shadowing. That's why it is used so little.
150 mkWildValBinder :: Type -> Id
151 mkWildValBinder ty = mkSysLocal (fsLit "wild") (mkBuiltinUnique 1) ty
153 mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr
154 -- Make a case expression whose case binder is unused
155 -- The alts should not have any occurrences of WildId
156 mkWildCase scrut scrut_ty res_ty alts
157 = Case scrut (mkWildValBinder scrut_ty) res_ty alts
159 mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr
160 mkIfThenElse guard then_expr else_expr
161 -- Not going to be refining, so okay to take the type of the "then" clause
162 = mkWildCase guard boolTy (exprType then_expr)
163 [ (DataAlt falseDataCon, [], else_expr), -- Increasing order of tag!
164 (DataAlt trueDataCon, [], then_expr) ]
167 The functions from this point don't really do anything cleverer than
168 their counterparts in CoreSyn, but they are here for consistency
171 -- | Create a lambda where the given expression has a number of variables
172 -- bound over it. The leftmost binder is that bound by the outermost
173 -- lambda in the result
174 mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
178 %************************************************************************
180 \subsection{Making literals}
182 %************************************************************************
185 -- | Create a 'CoreExpr' which will evaluate to the given @Int@
186 mkIntExpr :: Integer -> CoreExpr -- Result = I# i :: Int
187 mkIntExpr i = mkConApp intDataCon [mkIntLit i]
189 -- | Create a 'CoreExpr' which will evaluate to the given @Int@
190 mkIntExprInt :: Int -> CoreExpr -- Result = I# i :: Int
191 mkIntExprInt i = mkConApp intDataCon [mkIntLitInt i]
193 -- | Create a 'CoreExpr' which will evaluate to the a @Word@ with the given value
194 mkWordExpr :: Integer -> CoreExpr
195 mkWordExpr w = mkConApp wordDataCon [mkWordLit w]
197 -- | Create a 'CoreExpr' which will evaluate to the given @Word@
198 mkWordExprWord :: Word -> CoreExpr
199 mkWordExprWord w = mkConApp wordDataCon [mkWordLitWord w]
201 -- | Create a 'CoreExpr' which will evaluate to the given @Integer@
202 mkIntegerExpr :: MonadThings m => Integer -> m CoreExpr -- Result :: Integer
204 | inIntRange i -- Small enough, so start from an Int
205 = do integer_id <- lookupId smallIntegerName
206 return (mkSmallIntegerLit integer_id i)
208 -- Special case for integral literals with a large magnitude:
209 -- They are transformed into an expression involving only smaller
210 -- integral literals. This improves constant folding.
212 | otherwise = do -- Big, so start from a string
213 plus_id <- lookupId plusIntegerName
214 times_id <- lookupId timesIntegerName
215 integer_id <- lookupId smallIntegerName
217 lit i = mkSmallIntegerLit integer_id i
218 plus a b = Var plus_id `App` a `App` b
219 times a b = Var times_id `App` a `App` b
221 -- Transform i into (x1 + (x2 + (x3 + (...) * b) * b) * b) with abs xi <= b
222 horner :: Integer -> Integer -> CoreExpr
223 horner b i | abs q <= 1 = if r == 0 || r == i
225 else lit r `plus` lit (i-r)
226 | r == 0 = horner b q `times` lit b
227 | otherwise = lit r `plus` (horner b q `times` lit b)
229 (q,r) = i `quotRem` b
231 return (horner tARGET_MAX_INT i)
233 mkSmallIntegerLit :: Id -> Integer -> CoreExpr
234 mkSmallIntegerLit small_integer i = mkApps (Var small_integer) [mkIntLit i]
237 -- | Create a 'CoreExpr' which will evaluate to the given @Float@
238 mkFloatExpr :: Float -> CoreExpr
239 mkFloatExpr f = mkConApp floatDataCon [mkFloatLitFloat f]
241 -- | Create a 'CoreExpr' which will evaluate to the given @Double@
242 mkDoubleExpr :: Double -> CoreExpr
243 mkDoubleExpr d = mkConApp doubleDataCon [mkDoubleLitDouble d]
246 -- | Create a 'CoreExpr' which will evaluate to the given @Char@
247 mkCharExpr :: Char -> CoreExpr -- Result = C# c :: Int
248 mkCharExpr c = mkConApp charDataCon [mkCharLit c]
250 -- | Create a 'CoreExpr' which will evaluate to the given @String@
251 mkStringExpr :: MonadThings m => String -> m CoreExpr -- Result :: String
252 -- | Create a 'CoreExpr' which will evaluate to a string morally equivalent to the given @FastString@
253 mkStringExprFS :: MonadThings m => FastString -> m CoreExpr -- Result :: String
255 mkStringExpr str = mkStringExprFS (mkFastString str)
259 = return (mkNilExpr charTy)
262 = do let the_char = mkCharExpr (headFS str)
263 return (mkConsExpr charTy the_char (mkNilExpr charTy))
266 = do unpack_id <- lookupId unpackCStringName
267 return (App (Var unpack_id) (Lit (MachStr str)))
270 = do unpack_id <- lookupId unpackCStringUtf8Name
271 return (App (Var unpack_id) (Lit (MachStr str)))
275 safeChar c = ord c >= 1 && ord c <= 0x7F
278 %************************************************************************
280 \subsection{Tuple constructors}
282 %************************************************************************
289 -- GHCs built in tuples can only go up to 'mAX_TUPLE_SIZE' in arity, but
290 -- we might concievably want to build such a massive tuple as part of the
291 -- output of a desugaring stage (notably that for list comprehensions).
293 -- We call tuples above this size \"big tuples\", and emulate them by
294 -- creating and pattern matching on >nested< tuples that are expressible
297 -- Nesting policy: it's better to have a 2-tuple of 10-tuples (3 objects)
298 -- than a 10-tuple of 2-tuples (11 objects), so we want the leaves of any
299 -- construction to be big.
301 -- If you just use the 'mkBigCoreTup', 'mkBigCoreVarTupTy', 'mkTupleSelector'
302 -- and 'mkTupleCase' functions to do all your work with tuples you should be
303 -- fine, and not have to worry about the arity limitation at all.
305 -- | Lifts a \"small\" constructor into a \"big\" constructor by recursive decompositon
306 mkChunkified :: ([a] -> a) -- ^ \"Small\" constructor function, of maximum input arity 'mAX_TUPLE_SIZE'
307 -> [a] -- ^ Possible \"big\" list of things to construct from
308 -> a -- ^ Constructed thing made possible by recursive decomposition
309 mkChunkified small_tuple as = mk_big_tuple (chunkify as)
311 -- Each sub-list is short enough to fit in a tuple
312 mk_big_tuple [as] = small_tuple as
313 mk_big_tuple as_s = mk_big_tuple (chunkify (map small_tuple as_s))
315 chunkify :: [a] -> [[a]]
316 -- ^ Split a list into lists that are small enough to have a corresponding
317 -- tuple arity. The sub-lists of the result all have length <= 'mAX_TUPLE_SIZE'
318 -- But there may be more than 'mAX_TUPLE_SIZE' sub-lists
320 | n_xs <= mAX_TUPLE_SIZE = [xs]
321 | otherwise = split xs
325 split xs = take mAX_TUPLE_SIZE xs : split (drop mAX_TUPLE_SIZE xs)
329 Creating tuples and their types for Core expressions
331 @mkBigCoreVarTup@ builds a tuple; the inverse to @mkTupleSelector@.
333 * If it has only one element, it is the identity function.
335 * If there are more elements than a big tuple can have, it nests
340 -- | Build a small tuple holding the specified variables
341 mkCoreVarTup :: [Id] -> CoreExpr
342 mkCoreVarTup ids = mkCoreTup (map Var ids)
344 -- | Bulid the type of a small tuple that holds the specified variables
345 mkCoreVarTupTy :: [Id] -> Type
346 mkCoreVarTupTy ids = mkBoxedTupleTy (map idType ids)
348 -- | Build a small tuple holding the specified expressions
349 mkCoreTup :: [CoreExpr] -> CoreExpr
350 mkCoreTup [] = Var unitDataConId
352 mkCoreTup cs = mkConApp (tupleCon Boxed (length cs))
353 (map (Type . exprType) cs ++ cs)
355 -- | Build a big tuple holding the specified variables
356 mkBigCoreVarTup :: [Id] -> CoreExpr
357 mkBigCoreVarTup ids = mkBigCoreTup (map Var ids)
359 -- | Build the type of a big tuple that holds the specified variables
360 mkBigCoreVarTupTy :: [Id] -> Type
361 mkBigCoreVarTupTy ids = mkBigCoreTupTy (map idType ids)
363 -- | Build a big tuple holding the specified expressions
364 mkBigCoreTup :: [CoreExpr] -> CoreExpr
365 mkBigCoreTup = mkChunkified mkCoreTup
367 -- | Build the type of a big tuple that holds the specified type of thing
368 mkBigCoreTupTy :: [Type] -> Type
369 mkBigCoreTupTy = mkChunkified mkBoxedTupleTy
372 %************************************************************************
374 \subsection{Tuple destructors}
376 %************************************************************************
379 -- | Builds a selector which scrutises the given
380 -- expression and extracts the one name from the list given.
381 -- If you want the no-shadowing rule to apply, the caller
382 -- is responsible for making sure that none of these names
385 -- If there is just one 'Id' in the tuple, then the selector is
386 -- just the identity.
388 -- If necessary, we pattern match on a \"big\" tuple.
389 mkTupleSelector :: [Id] -- ^ The 'Id's to pattern match the tuple against
390 -> Id -- ^ The 'Id' to select
391 -> Id -- ^ A variable of the same type as the scrutinee
392 -> CoreExpr -- ^ Scrutinee
393 -> CoreExpr -- ^ Selector expression
395 -- mkTupleSelector [a,b,c,d] b v e
397 -- (p,q) -> case p of p {
399 -- We use 'tpl' vars for the p,q, since shadowing does not matter.
401 -- In fact, it's more convenient to generate it innermost first, getting
406 mkTupleSelector vars the_var scrut_var scrut
407 = mk_tup_sel (chunkify vars) the_var
409 mk_tup_sel [vars] the_var = mkSmallTupleSelector vars the_var scrut_var scrut
410 mk_tup_sel vars_s the_var = mkSmallTupleSelector group the_var tpl_v $
411 mk_tup_sel (chunkify tpl_vs) tpl_v
413 tpl_tys = [mkBoxedTupleTy (map idType gp) | gp <- vars_s]
414 tpl_vs = mkTemplateLocals tpl_tys
415 [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s,
420 -- | Like 'mkTupleSelector' but for tuples that are guaranteed
421 -- never to be \"big\".
423 -- > mkSmallTupleSelector [x] x v e = [| e |]
424 -- > mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]
425 mkSmallTupleSelector :: [Id] -- The tuple args
426 -> Id -- The selected one
427 -> Id -- A variable of the same type as the scrutinee
428 -> CoreExpr -- Scrutinee
430 mkSmallTupleSelector [var] should_be_the_same_var _ scrut
431 = ASSERT(var == should_be_the_same_var)
433 mkSmallTupleSelector vars the_var scrut_var scrut
434 = ASSERT( notNull vars )
435 Case scrut scrut_var (idType the_var)
436 [(DataAlt (tupleCon Boxed (length vars)), vars, Var the_var)]
440 -- | A generalization of 'mkTupleSelector', allowing the body
441 -- of the case to be an arbitrary expression.
443 -- To avoid shadowing, we use uniques to invent new variables.
445 -- If necessary we pattern match on a \"big\" tuple.
446 mkTupleCase :: UniqSupply -- ^ For inventing names of intermediate variables
447 -> [Id] -- ^ The tuple identifiers to pattern match on
448 -> CoreExpr -- ^ Body of the case
449 -> Id -- ^ A variable of the same type as the scrutinee
450 -> CoreExpr -- ^ Scrutinee
452 -- ToDo: eliminate cases where none of the variables are needed.
454 -- mkTupleCase uniqs [a,b,c,d] body v e
455 -- = case e of v { (p,q) ->
456 -- case p of p { (a,b) ->
457 -- case q of q { (c,d) ->
459 mkTupleCase uniqs vars body scrut_var scrut
460 = mk_tuple_case uniqs (chunkify vars) body
462 -- This is the case where don't need any nesting
463 mk_tuple_case _ [vars] body
464 = mkSmallTupleCase vars body scrut_var scrut
466 -- This is the case where we must make nest tuples at least once
467 mk_tuple_case us vars_s body
468 = let (us', vars', body') = foldr one_tuple_case (us, [], body) vars_s
469 in mk_tuple_case us' (chunkify vars') body'
471 one_tuple_case chunk_vars (us, vs, body)
472 = let (us1, us2) = splitUniqSupply us
473 scrut_var = mkSysLocal (fsLit "ds") (uniqFromSupply us1)
474 (mkBoxedTupleTy (map idType chunk_vars))
475 body' = mkSmallTupleCase chunk_vars body scrut_var (Var scrut_var)
476 in (us2, scrut_var:vs, body')
480 -- | As 'mkTupleCase', but for a tuple that is small enough to be guaranteed
481 -- not to need nesting.
483 :: [Id] -- ^ The tuple args
484 -> CoreExpr -- ^ Body of the case
485 -> Id -- ^ A variable of the same type as the scrutinee
486 -> CoreExpr -- ^ Scrutinee
489 mkSmallTupleCase [var] body _scrut_var scrut
490 = bindNonRec var scrut body
491 mkSmallTupleCase vars body scrut_var scrut
492 -- One branch no refinement?
493 = Case scrut scrut_var (exprType body) [(DataAlt (tupleCon Boxed (length vars)), vars, body)]
496 %************************************************************************
498 \subsection{Common list manipulation expressions}
500 %************************************************************************
502 Call the constructor Ids when building explicit lists, so that they
503 interact well with rules.
506 -- | Makes a list @[]@ for lists of the specified type
507 mkNilExpr :: Type -> CoreExpr
508 mkNilExpr ty = mkConApp nilDataCon [Type ty]
510 -- | Makes a list @(:)@ for lists of the specified type
511 mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr
512 mkConsExpr ty hd tl = mkConApp consDataCon [Type ty, hd, tl]
514 -- | Make a list containing the given expressions, where the list has the given type
515 mkListExpr :: Type -> [CoreExpr] -> CoreExpr
516 mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs
518 -- | Make a fully applied 'foldr' expression
519 mkFoldrExpr :: MonadThings m
520 => Type -- ^ Element type of the list
521 -> Type -- ^ Fold result type
522 -> CoreExpr -- ^ "Cons" function expression for the fold
523 -> CoreExpr -- ^ "Nil" expression for the fold
524 -> CoreExpr -- ^ List expression being folded acress
526 mkFoldrExpr elt_ty result_ty c n list = do
527 foldr_id <- lookupId foldrName
528 return (Var foldr_id `App` Type elt_ty
534 -- | Make a 'build' expression applied to a locally-bound worker function
535 mkBuildExpr :: (MonadThings m, MonadUnique m)
536 => Type -- ^ Type of list elements to be built
537 -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -- ^ Function that, given information about the 'Id's
538 -- of the binders for the build worker function, returns
539 -- the body of that worker
541 mkBuildExpr elt_ty mk_build_inside = do
542 [n_tyvar] <- newTyVars [alphaTyVar]
543 let n_ty = mkTyVarTy n_tyvar
544 c_ty = mkFunTys [elt_ty, n_ty] n_ty
545 [c, n] <- sequence [mkSysLocalM (fsLit "c") c_ty, mkSysLocalM (fsLit "n") n_ty]
547 build_inside <- mk_build_inside (c, c_ty) (n, n_ty)
549 build_id <- lookupId buildName
550 return $ Var build_id `App` Type elt_ty `App` mkLams [n_tyvar, c, n] build_inside
552 newTyVars tyvar_tmpls = do
554 return (zipWith setTyVarUnique tyvar_tmpls uniqs)