`M-x delete-trailing-whitespace` & `M-x untabify`...
[ghc.git] / compiler / coreSyn / MkCore.lhs
1 \begin{code}
2 {-# LANGUAGE CPP #-}
3 {-# OPTIONS_GHC -fno-warn-tabs #-}
4 -- The above warning supression flag is a temporary kludge.
5 -- While working on this module you are encouraged to remove it and
6 -- detab the module (please do the detabbing in a separate patch). See
7 --     http://ghc.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
8 -- for details
9
10 -- | Handy functions for creating much Core syntax
11 module MkCore (
12         -- * Constructing normal syntax
13         mkCoreLet, mkCoreLets,
14         mkCoreApp, mkCoreApps, mkCoreConApps,
15         mkCoreLams, mkWildCase, mkIfThenElse,
16         mkWildValBinder, mkWildEvBinder,
17         sortQuantVars, castBottomExpr,
18
19         -- * Constructing boxed literals
20         mkWordExpr, mkWordExprWord,
21         mkIntExpr, mkIntExprInt,
22         mkIntegerExpr,
23         mkFloatExpr, mkDoubleExpr,
24         mkCharExpr, mkStringExpr, mkStringExprFS,
25
26         -- * Floats
27         FloatBind(..), wrapFloat,
28
29         -- * Constructing equality evidence boxes
30         mkEqBox,
31
32         -- * Constructing general big tuples
33         -- $big_tuples
34         mkChunkified,
35
36         -- * Constructing small tuples
37         mkCoreVarTup, mkCoreVarTupTy, mkCoreTup,
38
39         -- * Constructing big tuples
40         mkBigCoreVarTup, mkBigCoreVarTupTy,
41         mkBigCoreTup, mkBigCoreTupTy,
42
43         -- * Deconstructing small tuples
44         mkSmallTupleSelector, mkSmallTupleCase,
45
46         -- * Deconstructing big tuples
47         mkTupleSelector, mkTupleCase,
48
49         -- * Constructing list expressions
50         mkNilExpr, mkConsExpr, mkListExpr,
51         mkFoldrExpr, mkBuildExpr,
52
53         -- * Error Ids
54         mkRuntimeErrorApp, mkImpossibleExpr, errorIds,
55         rEC_CON_ERROR_ID, iRREFUT_PAT_ERROR_ID, rUNTIME_ERROR_ID,
56         nON_EXHAUSTIVE_GUARDS_ERROR_ID, nO_METHOD_BINDING_ERROR_ID,
57         pAT_ERROR_ID, eRROR_ID, rEC_SEL_ERROR_ID, aBSENT_ERROR_ID,
58         uNDEFINED_ID, undefinedName
59     ) where
60
61 #include "HsVersions.h"
62
63 import Id
64 import Var      ( EvVar, setTyVarUnique )
65
66 import CoreSyn
67 import CoreUtils        ( exprType, needsCaseBinding, bindNonRec )
68 import Literal
69 import HscTypes
70
71 import TysWiredIn
72 import PrelNames
73
74 import TcType           ( mkSigmaTy )
75 import Type
76 import Coercion
77 import TysPrim
78 import DataCon          ( DataCon, dataConWorkId )
79 import IdInfo           ( vanillaIdInfo, setStrictnessInfo,
80                           setArityInfo )
81 import Demand
82 import Name      hiding ( varName )
83 import Outputable
84 import FastString
85 import UniqSupply
86 import BasicTypes
87 import Util
88 import Pair
89 import Constants
90 import DynFlags
91
92 import Data.Char        ( ord )
93 import Data.List
94 import Data.Ord
95 #if __GLASGOW_HASKELL__ < 709
96 import Data.Word        ( Word )
97 #endif
98
99 infixl 4 `mkCoreApp`, `mkCoreApps`
100 \end{code}
101
102 %************************************************************************
103 %*                                                                      *
104 \subsection{Basic CoreSyn construction}
105 %*                                                                      *
106 %************************************************************************
107
108 \begin{code}
109 sortQuantVars :: [Var] -> [Var]
110 -- Sort the variables (KindVars, TypeVars, and Ids)
111 -- into order: Kind, then Type, then Id
112 sortQuantVars = sortBy (comparing withCategory)
113   where
114     withCategory v = (category v, v)
115     category :: Var -> Int
116     category v
117      | isKindVar v = 1
118      | isTyVar   v = 2
119      | otherwise   = 3
120
121 -- | Bind a binding group over an expression, using a @let@ or @case@ as
122 -- appropriate (see "CoreSyn#let_app_invariant")
123 mkCoreLet :: CoreBind -> CoreExpr -> CoreExpr
124 mkCoreLet (NonRec bndr rhs) body        -- See Note [CoreSyn let/app invariant]
125   | needsCaseBinding (idType bndr) rhs
126   = Case rhs bndr (exprType body) [(DEFAULT,[],body)]
127 mkCoreLet bind body
128   = Let bind body
129
130 -- | Bind a list of binding groups over an expression. The leftmost binding
131 -- group becomes the outermost group in the resulting expression
132 mkCoreLets :: [CoreBind] -> CoreExpr -> CoreExpr
133 mkCoreLets binds body = foldr mkCoreLet body binds
134
135 -- | Construct an expression which represents the application of one expression
136 -- to the other
137 mkCoreApp :: CoreExpr -> CoreExpr -> CoreExpr
138 -- Check the invariant that the arg of an App is ok-for-speculation if unlifted
139 -- See CoreSyn Note [CoreSyn let/app invariant]
140 mkCoreApp fun (Type ty) = App fun (Type ty)
141 mkCoreApp fun (Coercion co) = App fun (Coercion co)
142 mkCoreApp fun arg       = ASSERT2( isFunTy fun_ty, ppr fun $$ ppr arg )
143                           mk_val_app fun arg arg_ty res_ty
144                       where
145                         fun_ty = exprType fun
146                         (arg_ty, res_ty) = splitFunTy fun_ty
147
148 -- | Construct an expression which represents the application of a number of
149 -- expressions to another. The leftmost expression in the list is applied first
150 mkCoreApps :: CoreExpr -> [CoreExpr] -> CoreExpr
151 -- Slightly more efficient version of (foldl mkCoreApp)
152 mkCoreApps orig_fun orig_args
153   = go orig_fun (exprType orig_fun) orig_args
154   where
155     go fun _      []               = fun
156     go fun fun_ty (Type ty : args) = go (App fun (Type ty)) (applyTy fun_ty ty) args
157     go fun fun_ty (Coercion co : args) = go (App fun (Coercion co)) (applyCo fun_ty co) args
158     go fun fun_ty (arg     : args) = ASSERT2( isFunTy fun_ty, ppr fun_ty $$ ppr orig_fun $$ ppr orig_args )
159                                      go (mk_val_app fun arg arg_ty res_ty) res_ty args
160                                    where
161                                      (arg_ty, res_ty) = splitFunTy fun_ty
162
163 -- | Construct an expression which represents the application of a number of
164 -- expressions to that of a data constructor expression. The leftmost expression
165 -- in the list is applied first
166 mkCoreConApps :: DataCon -> [CoreExpr] -> CoreExpr
167 mkCoreConApps con args = mkCoreApps (Var (dataConWorkId con)) args
168
169 -----------
170 mk_val_app :: CoreExpr -> CoreExpr -> Type -> Type -> CoreExpr
171 mk_val_app fun arg arg_ty _        -- See Note [CoreSyn let/app invariant]
172   | not (needsCaseBinding arg_ty arg)
173   = App fun arg                -- The vastly common case
174
175 mk_val_app fun arg arg_ty res_ty
176   = Case arg arg_id res_ty [(DEFAULT,[],App fun (Var arg_id))]
177   where
178     arg_id = mkWildValBinder arg_ty
179         -- Lots of shadowing, but it doesn't matter,
180         -- because 'fun ' should not have a free wild-id
181         --
182         -- This is Dangerous.  But this is the only place we play this
183         -- game, mk_val_app returns an expression that does not have
184         -- have a free wild-id.  So the only thing that can go wrong
185         -- is if you take apart this case expression, and pass a
186         -- fragmet of it as the fun part of a 'mk_val_app'.
187
188 mkWildEvBinder :: PredType -> EvVar
189 mkWildEvBinder pred = mkWildValBinder pred
190
191 -- | Make a /wildcard binder/. This is typically used when you need a binder
192 -- that you expect to use only at a *binding* site.  Do not use it at
193 -- occurrence sites because it has a single, fixed unique, and it's very
194 -- easy to get into difficulties with shadowing.  That's why it is used so little.
195 -- See Note [WildCard binders] in SimplEnv
196 mkWildValBinder :: Type -> Id
197 mkWildValBinder ty = mkLocalId wildCardName ty
198
199 mkWildCase :: CoreExpr -> Type -> Type -> [CoreAlt] -> CoreExpr
200 -- Make a case expression whose case binder is unused
201 -- The alts should not have any occurrences of WildId
202 mkWildCase scrut scrut_ty res_ty alts
203   = Case scrut (mkWildValBinder scrut_ty) res_ty alts
204
205 mkIfThenElse :: CoreExpr -> CoreExpr -> CoreExpr -> CoreExpr
206 mkIfThenElse guard then_expr else_expr
207 -- Not going to be refining, so okay to take the type of the "then" clause
208   = mkWildCase guard boolTy (exprType then_expr)
209          [ (DataAlt falseDataCon, [], else_expr),       -- Increasing order of tag!
210            (DataAlt trueDataCon,  [], then_expr) ]
211
212 castBottomExpr :: CoreExpr -> Type -> CoreExpr
213 -- (castBottomExpr e ty), assuming that 'e' diverges,
214 -- return an expression of type 'ty'
215 -- See Note [Empty case alternatives] in CoreSyn
216 castBottomExpr e res_ty
217   | e_ty `eqType` res_ty = e
218   | otherwise            = Case e (mkWildValBinder e_ty) res_ty []
219   where
220     e_ty = exprType e
221 \end{code}
222
223 The functions from this point don't really do anything cleverer than
224 their counterparts in CoreSyn, but they are here for consistency
225
226 \begin{code}
227 -- | Create a lambda where the given expression has a number of variables
228 -- bound over it. The leftmost binder is that bound by the outermost
229 -- lambda in the result
230 mkCoreLams :: [CoreBndr] -> CoreExpr -> CoreExpr
231 mkCoreLams = mkLams
232 \end{code}
233
234 %************************************************************************
235 %*                                                                      *
236 \subsection{Making literals}
237 %*                                                                      *
238 %************************************************************************
239
240 \begin{code}
241 -- | Create a 'CoreExpr' which will evaluate to the given @Int@
242 mkIntExpr :: DynFlags -> Integer -> CoreExpr        -- Result = I# i :: Int
243 mkIntExpr dflags i = mkConApp intDataCon  [mkIntLit dflags i]
244
245 -- | Create a 'CoreExpr' which will evaluate to the given @Int@
246 mkIntExprInt :: DynFlags -> Int -> CoreExpr         -- Result = I# i :: Int
247 mkIntExprInt dflags i = mkConApp intDataCon  [mkIntLitInt dflags i]
248
249 -- | Create a 'CoreExpr' which will evaluate to the a @Word@ with the given value
250 mkWordExpr :: DynFlags -> Integer -> CoreExpr
251 mkWordExpr dflags w = mkConApp wordDataCon [mkWordLit dflags w]
252
253 -- | Create a 'CoreExpr' which will evaluate to the given @Word@
254 mkWordExprWord :: DynFlags -> Word -> CoreExpr
255 mkWordExprWord dflags w = mkConApp wordDataCon [mkWordLitWord dflags w]
256
257 -- | Create a 'CoreExpr' which will evaluate to the given @Integer@
258 mkIntegerExpr  :: MonadThings m => Integer -> m CoreExpr  -- Result :: Integer
259 mkIntegerExpr i = do t <- lookupTyCon integerTyConName
260                      return (Lit (mkLitInteger i (mkTyConTy t)))
261
262 -- | Create a 'CoreExpr' which will evaluate to the given @Float@
263 mkFloatExpr :: Float -> CoreExpr
264 mkFloatExpr f = mkConApp floatDataCon [mkFloatLitFloat f]
265
266 -- | Create a 'CoreExpr' which will evaluate to the given @Double@
267 mkDoubleExpr :: Double -> CoreExpr
268 mkDoubleExpr d = mkConApp doubleDataCon [mkDoubleLitDouble d]
269
270
271 -- | Create a 'CoreExpr' which will evaluate to the given @Char@
272 mkCharExpr     :: Char             -> CoreExpr      -- Result = C# c :: Int
273 mkCharExpr c = mkConApp charDataCon [mkCharLit c]
274
275 -- | Create a 'CoreExpr' which will evaluate to the given @String@
276 mkStringExpr   :: MonadThings m => String     -> m CoreExpr  -- Result :: String
277 -- | Create a 'CoreExpr' which will evaluate to a string morally equivalent to the given @FastString@
278 mkStringExprFS :: MonadThings m => FastString -> m CoreExpr  -- Result :: String
279
280 mkStringExpr str = mkStringExprFS (mkFastString str)
281
282 mkStringExprFS str
283   | nullFS str
284   = return (mkNilExpr charTy)
285
286   | lengthFS str == 1
287   = do let the_char = mkCharExpr (headFS str)
288        return (mkConsExpr charTy the_char (mkNilExpr charTy))
289
290   | all safeChar chars
291   = do unpack_id <- lookupId unpackCStringName
292        return (App (Var unpack_id) (Lit (MachStr (fastStringToByteString str))))
293
294   | otherwise
295   = do unpack_id <- lookupId unpackCStringUtf8Name
296        return (App (Var unpack_id) (Lit (MachStr (fastStringToByteString str))))
297
298   where
299     chars = unpackFS str
300     safeChar c = ord c >= 1 && ord c <= 0x7F
301 \end{code}
302
303 \begin{code}
304
305 -- This take a ~# b (or a ~# R b) and returns a ~ b (or Coercible a b)
306 mkEqBox :: Coercion -> CoreExpr
307 mkEqBox co = ASSERT2( typeKind ty2 `eqKind` k, ppr co $$ ppr ty1 $$ ppr ty2 $$ ppr (typeKind ty1) $$ ppr (typeKind ty2) )
308              Var (dataConWorkId datacon) `mkTyApps` [k, ty1, ty2] `App` Coercion co
309   where (Pair ty1 ty2, role) = coercionKindRole co
310         k = typeKind ty1
311         datacon = case role of
312             Nominal ->          eqBoxDataCon
313             Representational -> coercibleDataCon
314             Phantom ->          pprPanic "mkEqBox does not support boxing phantom coercions"
315                                          (ppr co)
316 \end{code}
317
318 %************************************************************************
319 %*                                                                      *
320 \subsection{Tuple constructors}
321 %*                                                                      *
322 %************************************************************************
323
324 \begin{code}
325
326 -- $big_tuples
327 -- #big_tuples#
328 --
329 -- GHCs built in tuples can only go up to 'mAX_TUPLE_SIZE' in arity, but
330 -- we might concievably want to build such a massive tuple as part of the
331 -- output of a desugaring stage (notably that for list comprehensions).
332 --
333 -- We call tuples above this size \"big tuples\", and emulate them by
334 -- creating and pattern matching on >nested< tuples that are expressible
335 -- by GHC.
336 --
337 -- Nesting policy: it's better to have a 2-tuple of 10-tuples (3 objects)
338 -- than a 10-tuple of 2-tuples (11 objects), so we want the leaves of any
339 -- construction to be big.
340 --
341 -- If you just use the 'mkBigCoreTup', 'mkBigCoreVarTupTy', 'mkTupleSelector'
342 -- and 'mkTupleCase' functions to do all your work with tuples you should be
343 -- fine, and not have to worry about the arity limitation at all.
344
345 -- | Lifts a \"small\" constructor into a \"big\" constructor by recursive decompositon
346 mkChunkified :: ([a] -> a)      -- ^ \"Small\" constructor function, of maximum input arity 'mAX_TUPLE_SIZE'
347              -> [a]             -- ^ Possible \"big\" list of things to construct from
348              -> a               -- ^ Constructed thing made possible by recursive decomposition
349 mkChunkified small_tuple as = mk_big_tuple (chunkify as)
350   where
351         -- Each sub-list is short enough to fit in a tuple
352     mk_big_tuple [as] = small_tuple as
353     mk_big_tuple as_s = mk_big_tuple (chunkify (map small_tuple as_s))
354
355 chunkify :: [a] -> [[a]]
356 -- ^ Split a list into lists that are small enough to have a corresponding
357 -- tuple arity. The sub-lists of the result all have length <= 'mAX_TUPLE_SIZE'
358 -- But there may be more than 'mAX_TUPLE_SIZE' sub-lists
359 chunkify xs
360   | n_xs <= mAX_TUPLE_SIZE = [xs]
361   | otherwise              = split xs
362   where
363     n_xs     = length xs
364     split [] = []
365     split xs = take mAX_TUPLE_SIZE xs : split (drop mAX_TUPLE_SIZE xs)
366
367 \end{code}
368
369 Creating tuples and their types for Core expressions
370
371 @mkBigCoreVarTup@ builds a tuple; the inverse to @mkTupleSelector@.
372
373 * If it has only one element, it is the identity function.
374
375 * If there are more elements than a big tuple can have, it nests
376   the tuples.
377
378 \begin{code}
379
380 -- | Build a small tuple holding the specified variables
381 mkCoreVarTup :: [Id] -> CoreExpr
382 mkCoreVarTup ids = mkCoreTup (map Var ids)
383
384 -- | Bulid the type of a small tuple that holds the specified variables
385 mkCoreVarTupTy :: [Id] -> Type
386 mkCoreVarTupTy ids = mkBoxedTupleTy (map idType ids)
387
388 -- | Build a small tuple holding the specified expressions
389 mkCoreTup :: [CoreExpr] -> CoreExpr
390 mkCoreTup []  = Var unitDataConId
391 mkCoreTup [c] = c
392 mkCoreTup cs  = mkConApp (tupleCon BoxedTuple (length cs))
393                          (map (Type . exprType) cs ++ cs)
394
395 -- | Build a big tuple holding the specified variables
396 mkBigCoreVarTup :: [Id] -> CoreExpr
397 mkBigCoreVarTup ids = mkBigCoreTup (map Var ids)
398
399 -- | Build the type of a big tuple that holds the specified variables
400 mkBigCoreVarTupTy :: [Id] -> Type
401 mkBigCoreVarTupTy ids = mkBigCoreTupTy (map idType ids)
402
403 -- | Build a big tuple holding the specified expressions
404 mkBigCoreTup :: [CoreExpr] -> CoreExpr
405 mkBigCoreTup = mkChunkified mkCoreTup
406
407 -- | Build the type of a big tuple that holds the specified type of thing
408 mkBigCoreTupTy :: [Type] -> Type
409 mkBigCoreTupTy = mkChunkified mkBoxedTupleTy
410 \end{code}
411
412
413 %************************************************************************
414 %*                                                                      *
415                 Floats
416 %*                                                                      *
417 %************************************************************************
418
419 \begin{code}
420 data FloatBind
421   = FloatLet  CoreBind
422   | FloatCase CoreExpr Id AltCon [Var]
423       -- case e of y { C ys -> ... }
424       -- See Note [Floating cases] in SetLevels
425
426 instance Outputable FloatBind where
427   ppr (FloatLet b) = ptext (sLit "LET") <+> ppr b
428   ppr (FloatCase e b c bs) = hang (ptext (sLit "CASE") <+> ppr e <+> ptext (sLit "of") <+> ppr b)
429                                 2 (ppr c <+> ppr bs)
430
431 wrapFloat :: FloatBind -> CoreExpr -> CoreExpr
432 wrapFloat (FloatLet defns)       body = Let defns body
433 wrapFloat (FloatCase e b con bs) body = Case e b (exprType body) [(con, bs, body)]
434 \end{code}
435
436 %************************************************************************
437 %*                                                                      *
438 \subsection{Tuple destructors}
439 %*                                                                      *
440 %************************************************************************
441
442 \begin{code}
443 -- | Builds a selector which scrutises the given
444 -- expression and extracts the one name from the list given.
445 -- If you want the no-shadowing rule to apply, the caller
446 -- is responsible for making sure that none of these names
447 -- are in scope.
448 --
449 -- If there is just one 'Id' in the tuple, then the selector is
450 -- just the identity.
451 --
452 -- If necessary, we pattern match on a \"big\" tuple.
453 mkTupleSelector :: [Id]         -- ^ The 'Id's to pattern match the tuple against
454                 -> Id           -- ^ The 'Id' to select
455                 -> Id           -- ^ A variable of the same type as the scrutinee
456                 -> CoreExpr     -- ^ Scrutinee
457                 -> CoreExpr     -- ^ Selector expression
458
459 -- mkTupleSelector [a,b,c,d] b v e
460 --          = case e of v {
461 --                (p,q) -> case p of p {
462 --                           (a,b) -> b }}
463 -- We use 'tpl' vars for the p,q, since shadowing does not matter.
464 --
465 -- In fact, it's more convenient to generate it innermost first, getting
466 --
467 --        case (case e of v
468 --                (p,q) -> p) of p
469 --          (a,b) -> b
470 mkTupleSelector vars the_var scrut_var scrut
471   = mk_tup_sel (chunkify vars) the_var
472   where
473     mk_tup_sel [vars] the_var = mkSmallTupleSelector vars the_var scrut_var scrut
474     mk_tup_sel vars_s the_var = mkSmallTupleSelector group the_var tpl_v $
475                                 mk_tup_sel (chunkify tpl_vs) tpl_v
476         where
477           tpl_tys = [mkBoxedTupleTy (map idType gp) | gp <- vars_s]
478           tpl_vs  = mkTemplateLocals tpl_tys
479           [(tpl_v, group)] = [(tpl,gp) | (tpl,gp) <- zipEqual "mkTupleSelector" tpl_vs vars_s,
480                                          the_var `elem` gp ]
481 \end{code}
482
483 \begin{code}
484 -- | Like 'mkTupleSelector' but for tuples that are guaranteed
485 -- never to be \"big\".
486 --
487 -- > mkSmallTupleSelector [x] x v e = [| e |]
488 -- > mkSmallTupleSelector [x,y,z] x v e = [| case e of v { (x,y,z) -> x } |]
489 mkSmallTupleSelector :: [Id]        -- The tuple args
490           -> Id         -- The selected one
491           -> Id         -- A variable of the same type as the scrutinee
492           -> CoreExpr        -- Scrutinee
493           -> CoreExpr
494 mkSmallTupleSelector [var] should_be_the_same_var _ scrut
495   = ASSERT(var == should_be_the_same_var)
496     scrut
497 mkSmallTupleSelector vars the_var scrut_var scrut
498   = ASSERT( notNull vars )
499     Case scrut scrut_var (idType the_var)
500          [(DataAlt (tupleCon BoxedTuple (length vars)), vars, Var the_var)]
501 \end{code}
502
503 \begin{code}
504 -- | A generalization of 'mkTupleSelector', allowing the body
505 -- of the case to be an arbitrary expression.
506 --
507 -- To avoid shadowing, we use uniques to invent new variables.
508 --
509 -- If necessary we pattern match on a \"big\" tuple.
510 mkTupleCase :: UniqSupply       -- ^ For inventing names of intermediate variables
511             -> [Id]             -- ^ The tuple identifiers to pattern match on
512             -> CoreExpr         -- ^ Body of the case
513             -> Id               -- ^ A variable of the same type as the scrutinee
514             -> CoreExpr         -- ^ Scrutinee
515             -> CoreExpr
516 -- ToDo: eliminate cases where none of the variables are needed.
517 --
518 --         mkTupleCase uniqs [a,b,c,d] body v e
519 --           = case e of v { (p,q) ->
520 --             case p of p { (a,b) ->
521 --             case q of q { (c,d) ->
522 --             body }}}
523 mkTupleCase uniqs vars body scrut_var scrut
524   = mk_tuple_case uniqs (chunkify vars) body
525   where
526     -- This is the case where don't need any nesting
527     mk_tuple_case _ [vars] body
528       = mkSmallTupleCase vars body scrut_var scrut
529
530     -- This is the case where we must make nest tuples at least once
531     mk_tuple_case us vars_s body
532       = let (us', vars', body') = foldr one_tuple_case (us, [], body) vars_s
533             in mk_tuple_case us' (chunkify vars') body'
534
535     one_tuple_case chunk_vars (us, vs, body)
536       = let (uniq, us') = takeUniqFromSupply us
537             scrut_var = mkSysLocal (fsLit "ds") uniq
538               (mkBoxedTupleTy (map idType chunk_vars))
539             body' = mkSmallTupleCase chunk_vars body scrut_var (Var scrut_var)
540         in (us', scrut_var:vs, body')
541 \end{code}
542
543 \begin{code}
544 -- | As 'mkTupleCase', but for a tuple that is small enough to be guaranteed
545 -- not to need nesting.
546 mkSmallTupleCase
547         :: [Id]         -- ^ The tuple args
548         -> CoreExpr     -- ^ Body of the case
549         -> Id           -- ^ A variable of the same type as the scrutinee
550         -> CoreExpr     -- ^ Scrutinee
551         -> CoreExpr
552
553 mkSmallTupleCase [var] body _scrut_var scrut
554   = bindNonRec var scrut body
555 mkSmallTupleCase vars body scrut_var scrut
556 -- One branch no refinement?
557   = Case scrut scrut_var (exprType body) [(DataAlt (tupleCon BoxedTuple (length vars)), vars, body)]
558 \end{code}
559
560 %************************************************************************
561 %*                                                                      *
562 \subsection{Common list manipulation expressions}
563 %*                                                                      *
564 %************************************************************************
565
566 Call the constructor Ids when building explicit lists, so that they
567 interact well with rules.
568
569 \begin{code}
570 -- | Makes a list @[]@ for lists of the specified type
571 mkNilExpr :: Type -> CoreExpr
572 mkNilExpr ty = mkConApp nilDataCon [Type ty]
573
574 -- | Makes a list @(:)@ for lists of the specified type
575 mkConsExpr :: Type -> CoreExpr -> CoreExpr -> CoreExpr
576 mkConsExpr ty hd tl = mkConApp consDataCon [Type ty, hd, tl]
577
578 -- | Make a list containing the given expressions, where the list has the given type
579 mkListExpr :: Type -> [CoreExpr] -> CoreExpr
580 mkListExpr ty xs = foldr (mkConsExpr ty) (mkNilExpr ty) xs
581
582 -- | Make a fully applied 'foldr' expression
583 mkFoldrExpr :: MonadThings m
584             => Type             -- ^ Element type of the list
585             -> Type             -- ^ Fold result type
586             -> CoreExpr         -- ^ "Cons" function expression for the fold
587             -> CoreExpr         -- ^ "Nil" expression for the fold
588             -> CoreExpr         -- ^ List expression being folded acress
589             -> m CoreExpr
590 mkFoldrExpr elt_ty result_ty c n list = do
591     foldr_id <- lookupId foldrName
592     return (Var foldr_id `App` Type elt_ty
593            `App` Type result_ty
594            `App` c
595            `App` n
596            `App` list)
597
598 -- | Make a 'build' expression applied to a locally-bound worker function
599 mkBuildExpr :: (MonadThings m, MonadUnique m)
600             => Type                                     -- ^ Type of list elements to be built
601             -> ((Id, Type) -> (Id, Type) -> m CoreExpr) -- ^ Function that, given information about the 'Id's
602                                                         -- of the binders for the build worker function, returns
603                                                         -- the body of that worker
604             -> m CoreExpr
605 mkBuildExpr elt_ty mk_build_inside = do
606     [n_tyvar] <- newTyVars [alphaTyVar]
607     let n_ty = mkTyVarTy n_tyvar
608         c_ty = mkFunTys [elt_ty, n_ty] n_ty
609     [c, n] <- sequence [mkSysLocalM (fsLit "c") c_ty, mkSysLocalM (fsLit "n") n_ty]
610
611     build_inside <- mk_build_inside (c, c_ty) (n, n_ty)
612
613     build_id <- lookupId buildName
614     return $ Var build_id `App` Type elt_ty `App` mkLams [n_tyvar, c, n] build_inside
615   where
616     newTyVars tyvar_tmpls = do
617       uniqs <- getUniquesM
618       return (zipWith setTyVarUnique tyvar_tmpls uniqs)
619 \end{code}
620
621
622 %************************************************************************
623 %*                                                                      *
624                       Error expressions
625 %*                                                                      *
626 %************************************************************************
627
628 \begin{code}
629 mkRuntimeErrorApp
630         :: Id           -- Should be of type (forall a. Addr# -> a)
631                         --      where Addr# points to a UTF8 encoded string
632         -> Type         -- The type to instantiate 'a'
633         -> String       -- The string to print
634         -> CoreExpr
635
636 mkRuntimeErrorApp err_id res_ty err_msg
637   = mkApps (Var err_id) [Type res_ty, err_string]
638   where
639     err_string = Lit (mkMachString err_msg)
640
641 mkImpossibleExpr :: Type -> CoreExpr
642 mkImpossibleExpr res_ty
643   = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty "Impossible case alternative"
644 \end{code}
645
646 %************************************************************************
647 %*                                                                      *
648                      Error Ids
649 %*                                                                      *
650 %************************************************************************
651
652 GHC randomly injects these into the code.
653
654 @patError@ is just a version of @error@ for pattern-matching
655 failures.  It knows various ``codes'' which expand to longer
656 strings---this saves space!
657
658 @absentErr@ is a thing we put in for ``absent'' arguments.  They jolly
659 well shouldn't be yanked on, but if one is, then you will get a
660 friendly message from @absentErr@ (rather than a totally random
661 crash).
662
663 @parError@ is a special version of @error@ which the compiler does
664 not know to be a bottoming Id.  It is used in the @_par_@ and @_seq_@
665 templates, but we don't ever expect to generate code for it.
666
667 \begin{code}
668 errorIds :: [Id]
669 errorIds
670   = [ eRROR_ID,   -- This one isn't used anywhere else in the compiler
671                   -- But we still need it in wiredInIds so that when GHC
672                   -- compiles a program that mentions 'error' we don't
673                   -- import its type from the interface file; we just get
674                   -- the Id defined here.  Which has an 'open-tyvar' type.
675
676       uNDEFINED_ID,   -- Ditto for 'undefined'. The big deal is to give it
677                       -- an 'open-tyvar' type.
678
679       rUNTIME_ERROR_ID,
680       iRREFUT_PAT_ERROR_ID,
681       nON_EXHAUSTIVE_GUARDS_ERROR_ID,
682       nO_METHOD_BINDING_ERROR_ID,
683       pAT_ERROR_ID,
684       rEC_CON_ERROR_ID,
685       rEC_SEL_ERROR_ID,
686       aBSENT_ERROR_ID ]
687
688 recSelErrorName, runtimeErrorName, absentErrorName :: Name
689 irrefutPatErrorName, recConErrorName, patErrorName :: Name
690 nonExhaustiveGuardsErrorName, noMethodBindingErrorName :: Name
691
692 recSelErrorName     = err_nm "recSelError"     recSelErrorIdKey     rEC_SEL_ERROR_ID
693 absentErrorName     = err_nm "absentError"     absentErrorIdKey     aBSENT_ERROR_ID
694 runtimeErrorName    = err_nm "runtimeError"    runtimeErrorIdKey    rUNTIME_ERROR_ID
695 irrefutPatErrorName = err_nm "irrefutPatError" irrefutPatErrorIdKey iRREFUT_PAT_ERROR_ID
696 recConErrorName     = err_nm "recConError"     recConErrorIdKey     rEC_CON_ERROR_ID
697 patErrorName        = err_nm "patError"        patErrorIdKey        pAT_ERROR_ID
698
699 noMethodBindingErrorName     = err_nm "noMethodBindingError"
700                                   noMethodBindingErrorIdKey nO_METHOD_BINDING_ERROR_ID
701 nonExhaustiveGuardsErrorName = err_nm "nonExhaustiveGuardsError"
702                                   nonExhaustiveGuardsErrorIdKey nON_EXHAUSTIVE_GUARDS_ERROR_ID
703
704 err_nm :: String -> Unique -> Id -> Name
705 err_nm str uniq id = mkWiredInIdName cONTROL_EXCEPTION_BASE (fsLit str) uniq id
706
707 rEC_SEL_ERROR_ID, rUNTIME_ERROR_ID, iRREFUT_PAT_ERROR_ID, rEC_CON_ERROR_ID :: Id
708 pAT_ERROR_ID, nO_METHOD_BINDING_ERROR_ID, nON_EXHAUSTIVE_GUARDS_ERROR_ID :: Id
709 aBSENT_ERROR_ID :: Id
710 rEC_SEL_ERROR_ID                = mkRuntimeErrorId recSelErrorName
711 rUNTIME_ERROR_ID                = mkRuntimeErrorId runtimeErrorName
712 iRREFUT_PAT_ERROR_ID            = mkRuntimeErrorId irrefutPatErrorName
713 rEC_CON_ERROR_ID                = mkRuntimeErrorId recConErrorName
714 pAT_ERROR_ID                    = mkRuntimeErrorId patErrorName
715 nO_METHOD_BINDING_ERROR_ID      = mkRuntimeErrorId noMethodBindingErrorName
716 nON_EXHAUSTIVE_GUARDS_ERROR_ID  = mkRuntimeErrorId nonExhaustiveGuardsErrorName
717 aBSENT_ERROR_ID                 = mkRuntimeErrorId absentErrorName
718
719 mkRuntimeErrorId :: Name -> Id
720 mkRuntimeErrorId name = pc_bottoming_Id1 name runtimeErrorTy
721
722 runtimeErrorTy :: Type
723 -- The runtime error Ids take a UTF8-encoded string as argument
724 runtimeErrorTy = mkSigmaTy [openAlphaTyVar] [] (mkFunTy addrPrimTy openAlphaTy)
725 \end{code}
726
727 \begin{code}
728 errorName :: Name
729 errorName = mkWiredInIdName gHC_ERR (fsLit "error") errorIdKey eRROR_ID
730
731 eRROR_ID :: Id
732 eRROR_ID = pc_bottoming_Id1 errorName errorTy
733
734 errorTy  :: Type   -- See Note [Error and friends have an "open-tyvar" forall]
735 errorTy  = mkSigmaTy [openAlphaTyVar] [] (mkFunTys [mkListTy charTy] openAlphaTy)
736
737 undefinedName :: Name
738 undefinedName = mkWiredInIdName gHC_ERR (fsLit "undefined") undefinedKey uNDEFINED_ID
739
740 uNDEFINED_ID :: Id
741 uNDEFINED_ID = pc_bottoming_Id0 undefinedName undefinedTy
742
743 undefinedTy  :: Type   -- See Note [Error and friends have an "open-tyvar" forall]
744 undefinedTy  = mkSigmaTy [openAlphaTyVar] [] openAlphaTy
745 \end{code}
746
747 Note [Error and friends have an "open-tyvar" forall]
748 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
749 'error' and 'undefined' have types
750         error     :: forall (a::OpenKind). String -> a
751         undefined :: forall (a::OpenKind). a
752 Notice the 'OpenKind' (manifested as openAlphaTyVar in the code). This ensures that
753 "error" can be instantiated at
754   * unboxed as well as boxed types
755   * polymorphic types
756 This is OK because it never returns, so the return type is irrelevant.
757 See Note [OpenTypeKind accepts foralls] in TcUnify.
758
759
760 %************************************************************************
761 %*                                                                      *
762 \subsection{Utilities}
763 %*                                                                      *
764 %************************************************************************
765
766 \begin{code}
767 pc_bottoming_Id1 :: Name -> Type -> Id
768 -- Function of arity 1, which diverges after being given one argument
769 pc_bottoming_Id1 name ty
770  = mkVanillaGlobalWithInfo name ty bottoming_info
771  where
772     bottoming_info = vanillaIdInfo `setStrictnessInfo`    strict_sig
773                                    `setArityInfo`         1
774                         -- Make arity and strictness agree
775
776         -- Do *not* mark them as NoCafRefs, because they can indeed have
777         -- CAF refs.  For example, pAT_ERROR_ID calls GHC.Err.untangle,
778         -- which has some CAFs
779         -- In due course we may arrange that these error-y things are
780         -- regarded by the GC as permanently live, in which case we
781         -- can give them NoCaf info.  As it is, any function that calls
782         -- any pc_bottoming_Id will itself have CafRefs, which bloats
783         -- SRTs.
784
785     strict_sig = mkClosedStrictSig [evalDmd] botRes
786     -- These "bottom" out, no matter what their arguments
787
788 pc_bottoming_Id0 :: Name -> Type -> Id
789 -- Same but arity zero
790 pc_bottoming_Id0 name ty
791  = mkVanillaGlobalWithInfo name ty bottoming_info
792  where
793     bottoming_info = vanillaIdInfo `setStrictnessInfo` strict_sig
794     strict_sig = mkClosedStrictSig [] botRes
795 \end{code}