DsUtils.lhs 27.9 KB
Newer Older
1
%
Simon Marlow's avatar
Simon Marlow committed
2
% (c) The University of Glasgow 2006
3
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4
%
Simon Marlow's avatar
Simon Marlow committed
5 6

Utilities for desugaring
7 8 9 10

This module exports some utility functions of no great interest.

\begin{code}
Ian Lynagh's avatar
Ian Lynagh committed
11 12 13 14 15 16 17
{-# OPTIONS -fno-warn-tabs #-}
-- The above warning supression flag is a temporary kludge.
-- While working on this module you are encouraged to remove it and
-- detab the module (please do the detabbing in a separate patch). See
--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
-- for details

18
-- | Utility functions for constructing Core syntax, principally for desugaring
19
module DsUtils (
20 21
	EquationInfo(..), 
	firstPat, shiftEqns,
22

23 24 25 26
	MatchResult(..), CanItFail(..), 
	cantFailMatchResult, alwaysFailMatchResult,
	extractMatchResult, combineMatchResults, 
	adjustMatchResult,  adjustMatchResultDs,
27
	mkCoLetMatchResult, mkViewMatchResult, mkGuardedMatchResult, 
28
	matchCanFail, mkEvalMatchResult,
29
	mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult,
30
	wrapBind, wrapBinds,
31

32
	mkErrorAppDs, mkCoreAppDs, mkCoreAppsDs,
33 34 35 36

        seqVar,

        -- LHs tuples
37
        mkLHsVarPatTup, mkLHsPatTup, mkVanillaTuplePat,
38 39 40 41
        mkBigLHsVarTup, mkBigLHsTup, mkBigLHsVarPatTup, mkBigLHsPatTup,

        mkSelectorBinds,

andy@galois.com's avatar
andy@galois.com committed
42
	selectSimpleMatchVarL, selectMatchVars, selectMatchVar,
43
        mkOptTickBox, mkBinaryTickBox
44 45
    ) where

46 47
#include "HsVersions.h"

48
import {-# SOURCE #-}	Match ( matchSimply )
49

50
import HsSyn
Simon Marlow's avatar
Simon Marlow committed
51
import TcHsSyn
52
import TcType( tcSplitTyConApp )
53 54 55
import CoreSyn
import DsMonad

Simon Marlow's avatar
Simon Marlow committed
56
import CoreUtils
57
import MkCore
Simon Marlow's avatar
Simon Marlow committed
58 59 60 61 62 63 64 65 66 67 68 69
import MkId
import Id
import Literal
import TyCon
import DataCon
import Type
import Coercion
import TysPrim
import TysWiredIn
import BasicTypes
import UniqSet
import UniqSupply
70
import Module
Simon Marlow's avatar
Simon Marlow committed
71
import PrelNames
sof's avatar
sof committed
72
import Outputable
Simon Marlow's avatar
Simon Marlow committed
73 74
import SrcLoc
import Util
Ian Lynagh's avatar
Ian Lynagh committed
75
import DynFlags
76
import FastString
77 78

import Control.Monad    ( zipWithM )
79 80
\end{code}

sof's avatar
sof committed
81 82 83

%************************************************************************
%*									*
84
\subsection{ Selecting match variables}
sof's avatar
sof committed
85 86 87 88 89 90 91 92 93
%*									*
%************************************************************************

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}
94
selectSimpleMatchVarL :: LPat Id -> DsM Id
95
selectSimpleMatchVarL pat = selectMatchVar (unLoc pat)
96 97 98 99

-- (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.
100 101 102
--
-- OLD, but interesting note:
--    But even if it is a variable, its type might not match.  Consider
103 104 105 106 107 108 109
--	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
110 111 112 113 114 115
--    Then we must not choose (x::Int) as the matching variable!
-- And nowadays we won't, because the (x::Int) will be wrapped in a CoPat

selectMatchVars :: [Pat Id] -> DsM [Id]
selectMatchVars ps = mapM selectMatchVar ps

116
selectMatchVar :: Pat Id -> DsM Id
117 118 119
selectMatchVar (BangPat pat) = selectMatchVar (unLoc pat)
selectMatchVar (LazyPat pat) = selectMatchVar (unLoc pat)
selectMatchVar (ParPat pat)  = selectMatchVar (unLoc pat)
120
selectMatchVar (VarPat var)  = return (localiseId var)  -- Note [Localise pattern binders]
121
selectMatchVar (AsPat var _) = return (unLoc var)
122
selectMatchVar other_pat     = newSysLocalDs (hsPatType other_pat)
123
				  -- OK, better make up one...
sof's avatar
sof committed
124 125
\end{code}

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
Note [Localise pattern binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider     module M where
               [Just a] = e
After renaming it looks like
             module M where
               [Just M.a] = e

We don't generalise, since it's a pattern binding, monomorphic, etc,
so after desugaring we may get something like
             M.a = case e of (v:_) ->
                   case v of Just M.a -> M.a
Notice the "M.a" in the pattern; after all, it was in the original
pattern.  However, after optimisation those pattern binders can become
let-binders, and then end up floated to top level.  They have a
different *unique* by then (the simplifier is good about maintaining
proper scoping), but it's BAD to have two top-level bindings with the
External Name M.a, because that turns into two linker symbols for M.a.
It's quite rare for this to actually *happen* -- the only case I know
of is tc003 compiled with the 'hpc' way -- but that only makes it 
all the more annoying.

To avoid this, we craftily call 'localiseId' in the desugarer, which
simply turns the External Name for the Id into an Internal one, but
doesn't change the unique.  So the desugarer produces this:
             M.a{r8} = case e of (v:_) ->
                       case v of Just a{r8} -> M.a{r8}
The unique is still 'r8', but the binding site in the pattern
is now an Internal Name.  Now the simplifier's usual mechanisms
will propagate that Name to all the occurrence sites, as well as
un-shadowing it, so we'll get
             M.a{r8} = case e of (v:_) ->
                       case v of Just a{s77} -> a{s77}
In fact, even CoreSubst.simplOptExpr will do this, and simpleOptExpr
runs on the output of the desugarer, so all is well by the end of
the desugaring pass.

sof's avatar
sof committed
163

164 165 166 167 168 169 170 171 172 173 174
%************************************************************************
%*									*
%* type synonym EquationInfo and access functions for its pieces	*
%*									*
%************************************************************************
\subsection[EquationInfo-synonym]{@EquationInfo@: a useful synonym}

The ``equation info'' used by @match@ is relatively complicated and
worthy of a type synonym and a few handy functions.

\begin{code}
175
firstPat :: EquationInfo -> Pat Id
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
176
firstPat eqn = ASSERT( notNull (eqn_pats eqn) ) head (eqn_pats eqn)
177

178
shiftEqns :: [EquationInfo] -> [EquationInfo]
179 180
-- Drop the first pattern in each equation
shiftEqns eqns = [ eqn { eqn_pats = tail (eqn_pats eqn) } | eqn <- eqns ]
181 182
\end{code}

183 184 185
Functions on MatchResults

\begin{code}
186 187 188 189
matchCanFail :: MatchResult -> Bool
matchCanFail (MatchResult CanFail _)  = True
matchCanFail (MatchResult CantFail _) = False

190
alwaysFailMatchResult :: MatchResult
191
alwaysFailMatchResult = MatchResult CanFail (\fail -> return fail)
192

193
cantFailMatchResult :: CoreExpr -> MatchResult
194
cantFailMatchResult expr = MatchResult CantFail (\_ -> return expr)
195

196
extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr
197
extractMatchResult (MatchResult CantFail match_fn) _
198
  = match_fn (error "It can't fail!")
199

200 201 202
extractMatchResult (MatchResult CanFail match_fn) fail_expr = do
    (fail_bind, if_it_fails) <- mkFailurePair fail_expr
    body <- match_fn if_it_fails
203
    return (mkCoreLet fail_bind body)
204

205 206 207

combineMatchResults :: MatchResult -> MatchResult -> MatchResult
combineMatchResults (MatchResult CanFail      body_fn1)
208
                    (MatchResult can_it_fail2 body_fn2)
209 210
  = MatchResult can_it_fail2 body_fn
  where
211 212 213 214
    body_fn fail = do body2 <- body_fn2 fail
                      (fail_bind, duplicatable_expr) <- mkFailurePair body2
                      body1 <- body_fn1 duplicatable_expr
                      return (Let fail_bind body1)
215

216
combineMatchResults match_result1@(MatchResult CantFail _) _
217 218
  = match_result1

219
adjustMatchResult :: DsWrapper -> MatchResult -> MatchResult
220
adjustMatchResult encl_fn (MatchResult can_it_fail body_fn)
221
  = MatchResult can_it_fail (\fail -> encl_fn <$> body_fn fail)
222 223 224

adjustMatchResultDs :: (CoreExpr -> DsM CoreExpr) -> MatchResult -> MatchResult
adjustMatchResultDs encl_fn (MatchResult can_it_fail body_fn)
225
  = MatchResult can_it_fail (\fail -> encl_fn =<< body_fn fail)
226

227 228 229
wrapBinds :: [(Var,Var)] -> CoreExpr -> CoreExpr
wrapBinds [] e = e
wrapBinds ((new,old):prs) e = wrapBind new old (wrapBinds prs e)
230

231
wrapBind :: Var -> Var -> CoreExpr -> CoreExpr
232 233 234
wrapBind new old body	-- NB: this function must deal with term
  | new==old    = body	-- variables, type variables or coercion variables
  | otherwise   = Let (NonRec new (varToCoreExpr old)) body
235

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
236 237 238 239
seqVar :: Var -> CoreExpr -> CoreExpr
seqVar var body = Case (Var var) var (exprType body)
			[(DEFAULT, [], body)]

240
mkCoLetMatchResult :: CoreBind -> MatchResult -> MatchResult
241
mkCoLetMatchResult bind = adjustMatchResult (mkCoreLet bind)
242

243 244 245 246
-- (mkViewMatchResult var' viewExpr var mr) makes the expression
-- let var' = viewExpr var in mr
mkViewMatchResult :: Id -> CoreExpr -> Id -> MatchResult -> MatchResult
mkViewMatchResult var' viewExpr var = 
247
    adjustMatchResult (mkCoreLet (NonRec var' (mkCoreAppDs viewExpr (Var var))))
248

249 250 251
mkEvalMatchResult :: Id -> Type -> MatchResult -> MatchResult
mkEvalMatchResult var ty
  = adjustMatchResult (\e -> Case (Var var) var ty [(DEFAULT, [], e)]) 
252 253

mkGuardedMatchResult :: CoreExpr -> MatchResult -> MatchResult
254
mkGuardedMatchResult pred_expr (MatchResult _ body_fn)
255 256
  = MatchResult CanFail (\fail -> do body <- body_fn fail
                                     return (mkIfThenElse pred_expr body fail))
257 258

mkCoPrimCaseMatchResult :: Id				-- Scrutinee
259
                    -> Type                             -- Type of the case
260
		    -> [(Literal, MatchResult)]		-- Alternatives
261
		    -> MatchResult			-- Literals are all unlifted
262
mkCoPrimCaseMatchResult var ty match_alts
263
  = MatchResult CanFail mk_case
264
  where
265 266 267
    mk_case fail = do
        alts <- mapM (mk_alt fail) sorted_alts
        return (Case (Var var) var ty ((DEFAULT, [], fail) : alts))
268

269
    sorted_alts = sortWith fst match_alts	-- Right order for a Case
270 271 272 273
    mk_alt fail (lit, MatchResult _ body_fn)
       = ASSERT( not (litIsLifted lit) )
         do body <- body_fn fail
            return (LitAlt lit, [], body)
274 275


276
mkCoAlgCaseMatchResult 
277 278
  :: DynFlags
  -> Id					   -- Scrutinee
279 280 281
  -> Type                                  -- Type of exp
  -> [(DataCon, [CoreBndr], MatchResult)]  -- Alternatives (bndrs *include* tyvars, dicts)
  -> MatchResult
282
mkCoAlgCaseMatchResult dflags var ty match_alts 
283
  | isNewTyCon tycon		-- Newtype case; use a let
284
  = ASSERT( null (tail match_alts) && null (tail arg_ids1) )
285
    mkCoLetMatchResult (NonRec arg_id1 newtype_rhs) match_result1
286

chak's avatar
chak committed
287 288 289
  | isPArrFakeAlts match_alts	-- Sugared parallel array; use a literal case 
  = MatchResult CanFail mk_parrCase

290 291
  | otherwise			-- Datatype case; use a case
  = MatchResult fail_flag mk_case
292
  where
293 294 295
    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]
296 297

	-- Stuff for newtype
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
298 299
    (con1, arg_ids1, match_result1) = ASSERT( notNull match_alts ) head match_alts
    arg_id1 	= ASSERT( notNull arg_ids1 ) head arg_ids1
300
    var_ty      = idType var
301 302
    (tc, ty_args) = tcSplitTyConApp var_ty	-- Don't look through newtypes
    	 	    		    		-- (not that splitTyConApp does, these days)
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
303
    newtype_rhs = unwrapNewTypeBody tc ty_args (Var var)
304
		
305
	-- Stuff for data types
306 307
    data_cons      = tyConDataCons tycon
    match_results  = [match_result | (_,_,match_result) <- match_alts]
308

309 310 311 312
    fail_flag | exhaustive_case
	      = foldr1 orFail [can_it_fail | MatchResult can_it_fail _ <- match_results]
	      | otherwise
	      = CanFail
313

314 315
    sorted_alts  = sortWith get_tag match_alts
    get_tag (con, _, _) = dataConTag con
316
    mk_case fail = do alts <- mapM (mk_alt fail) sorted_alts
317
                      return (mkWildCase (Var var) (idType var) ty (mk_default fail ++ alts))
318

319 320 321 322 323 324 325 326
    mk_alt fail (con, args, MatchResult _ body_fn)
      = do { body <- body_fn fail
           ; case dataConBoxer con of {
                Nothing -> return (DataAlt con, args, body) ;
                Just (DCB boxer) -> 
        do { us <- newUniqueSupply
           ; let (rep_ids, binds) = initUs_ us (boxer ty_args args)
           ; return (DataAlt con, rep_ids, mkLets binds body) } } }
327

328 329
    mk_default fail | exhaustive_case = []
		    | otherwise       = [(DEFAULT, [], fail)]
330

331 332 333
    un_mentioned_constructors
        = mkUniqSet data_cons `minusUniqSet` mkUniqSet [ con | (con, _, _) <- match_alts]
    exhaustive_case = isEmptyUniqSet un_mentioned_constructors
chak's avatar
chak committed
334 335 336

	-- Stuff for parallel arrays
	-- 
337
	--  * the following is to desugar cases over fake constructors for
chak's avatar
chak committed
338 339 340 341 342
	--   parallel arrays, which are introduced by `tidy1' in the `PArrPat'
	--   case
	--
	-- Concerning `isPArrFakeAlts':
	--
343
	--  * it is *not* sufficient to just check the type of the type
chak's avatar
chak committed
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361
	--   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
362 363
        _              -> panic "DsUtils: you may not mix `[:...:]' with `PArr' patterns"
    isPArrFakeAlts [] = panic "DsUtils: unexpectedly found an empty list of PArr fake alternatives"
chak's avatar
chak committed
364
    --
365
    mk_parrCase fail = do
366
      lengthP <- dsDPHBuiltin lengthPVar
367
      alt <- unboxAlt
368
      return (mkWildCase (len lengthP) intTy ty [alt])
chak's avatar
chak committed
369 370 371 372 373 374 375
      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]
	--
376 377
	unboxAlt = do
	  l      <- newSysLocalDs intPrimTy
378
	  indexP <- dsDPHBuiltin indexPVar
379
	  alts   <- mapM (mkAlt indexP) sorted_alts
380
	  return (DataAlt intDataCon, [l], mkWildCase (Var l) intPrimTy ty (dft : alts))
chak's avatar
chak committed
381 382 383 384 385 386 387 388 389
          where
	    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
	--
390 391
	mkAlt indexP (con, args, MatchResult _ bodyFun) = do
	  body <- bodyFun fail
392
	  return (LitAlt lit, [], mkCoreLets binds body)
chak's avatar
chak committed
393 394 395 396
	  where
	    lit   = MachInt $ toInteger (dataConSourceArity con)
	    binds = [NonRec arg (indexExpr i) | (i, arg) <- zip [1..] args]
	    --
397
	    indexExpr i = mkApps (Var indexP) [Type elemTy, Var var, mkIntExpr dflags i]
398
\end{code}
399

400 401
%************************************************************************
%*									*
402
\subsection{Desugarer's versions of some Core functions}
403 404 405 406
%*									*
%************************************************************************

\begin{code}
407 408
mkErrorAppDs :: Id 		-- The error function
	     -> Type		-- Type to which it should be applied
409
	     -> SDoc		-- The error message string to pass
410 411
	     -> DsM CoreExpr

412 413
mkErrorAppDs err_id ty msg = do
    src_loc <- getSrcSpanDs
Ian Lynagh's avatar
Ian Lynagh committed
414
    dflags <- getDynFlags
415
    let
Ian Lynagh's avatar
Ian Lynagh committed
416
        full_msg = showSDoc dflags (hcat [ppr src_loc, text "|", msg])
417 418
        core_msg = Lit (mkMachString full_msg)
        -- mkMachString returns a result of type String#
419
    return (mkApps (Var err_id) [Type ty, core_msg])
420 421
\end{code}

422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439
'mkCoreAppDs' and 'mkCoreAppsDs' hand the special-case desugaring of 'seq'.

Note [Desugaring seq (1)]  cf Trac #1031
~~~~~~~~~~~~~~~~~~~~~~~~~
   f x y = x `seq` (y `seq` (# x,y #))

The [CoreSyn let/app invariant] means that, other things being equal, because 
the argument to the outer 'seq' has an unlifted type, we'll use call-by-value thus:

   f x y = case (y `seq` (# x,y #)) of v -> x `seq` v

But that is bad for two reasons: 
  (a) we now evaluate y before x, and 
  (b) we can't bind v to an unboxed pair

Seq is very, very special!  So we recognise it right here, and desugar to
        case x of _ -> case y of _ -> (# x,y #)

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
440
Note [Desugaring seq (2)]  cf Trac #2273
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   let chp = case b of { True -> fst x; False -> 0 }
   in chp `seq` ...chp...
Here the seq is designed to plug the space leak of retaining (snd x)
for too long.

If we rely on the ordinary inlining of seq, we'll get
   let chp = case b of { True -> fst x; False -> 0 }
   case chp of _ { I# -> ...chp... }

But since chp is cheap, and the case is an alluring contet, we'll
inline chp into the case scrutinee.  Now there is only one use of chp,
so we'll inline a second copy.  Alas, we've now ruined the purpose of
the seq, by re-introducing the space leak:
    case (case b of {True -> fst x; False -> 0}) of
      I# _ -> ...case b of {True -> fst x; False -> 0}...

We can try to avoid doing this by ensuring that the binder-swap in the
case happens, so we get his at an early stage:
   case chp of chp2 { I# -> ...chp2... }
But this is fragile.  The real culprit is the source program.  Perhaps we
should have said explicitly
   let !chp2 = chp in ...chp2...

But that's painful.  So the code here does a little hack to make seq
more robust: a saturated application of 'seq' is turned *directly* into
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
468 469 470 471 472
the case expression, thus:
   x  `seq` e2 ==> case x of x -> e2    -- Note shadowing!
   e1 `seq` e2 ==> case x of _ -> e2

So we desugar our example to:
473 474
   let chp = case b of { True -> fst x; False -> 0 }
   case chp of chp { I# -> ...chp... }
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
475
And now all is well.
476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495

The reason it's a hack is because if you define mySeq=seq, the hack
won't work on mySeq.  

Note [Desugaring seq (3)] cf Trac #2409
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The isLocalId ensures that we don't turn 
        True `seq` e
into
        case True of True { ... }
which stupidly tries to bind the datacon 'True'. 

\begin{code}
mkCoreAppDs  :: CoreExpr -> CoreExpr -> CoreExpr
mkCoreAppDs (Var f `App` Type ty1 `App` Type ty2 `App` arg1) arg2
  | f `hasKey` seqIdKey            -- Note [Desugaring seq (1), (2)]
  = Case arg1 case_bndr ty2 [(DEFAULT,[],arg2)]
  where
    case_bndr = case arg1 of
                   Var v1 | isLocalId v1 -> v1        -- Note [Desugaring seq (2) and (3)]
496
                   _                     -> mkWildValBinder ty1
497 498 499 500 501 502 503 504

mkCoreAppDs fun arg = mkCoreApp fun arg	 -- The rest is done in MkCore

mkCoreAppsDs :: CoreExpr -> [CoreExpr] -> CoreExpr
mkCoreAppsDs fun args = foldl mkCoreAppDs fun args
\end{code}


505 506 507 508 509 510 511 512
%************************************************************************
%*									*
\subsection[mkSelectorBind]{Make a selector bind}
%*									*
%************************************************************************

This is used in various places to do with lazy patterns.
For each binder $b$ in the pattern, we create a binding:
513
\begin{verbatim}
514
    b = case v of pat' -> b'
515 516
\end{verbatim}
where @pat'@ is @pat@ with each binder @b@ cloned into @b'@.
517 518 519 520 521 522 523 524 525 526

ToDo: making these bindings should really depend on whether there's
much work to be done per binding.  If the pattern is complex, it
should be de-mangled once, into a tuple (and then selected from).
Otherwise the demangling can be in-line in the bindings (as here).

Boring!  Boring!  One error message per binder.  The above ToDo is
even more helpful.  Something very similar happens for pattern-bound
expressions.

527 528 529 530 531 532 533
Note [mkSelectorBinds]
~~~~~~~~~~~~~~~~~~~~~~
Given   p = e, where p binds x,y
we are going to make EITHER

EITHER (A)   v = e   (where v is fresh)
             x = case v of p -> x
Ian Lynagh's avatar
Ian Lynagh committed
534
             y = case v of p -> y
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552

OR (B)       t = case e of p -> (x,y)
             x = case t of (x,_) -> x
             y = case t of (_,y) -> y

We do (A) when 
 * Matching the pattern is cheap so we don't mind
   doing it twice.  
 * Or if the pattern binds only one variable (so we'll only
   match once)
 * AND the pattern can't fail (else we tiresomely get two inexhaustive 
   pattern warning messages)

Otherwise we do (B).  Really (A) is just an optimisation for very common
cases like
     Just x = e
     (p,q) = e

553
\begin{code}
554 555
mkSelectorBinds :: [Maybe (Tickish Id)]  -- ticks to add, possibly
                -> LPat Id      -- The pattern
556
		-> CoreExpr	-- Expression to which the pattern is bound
557
		-> DsM [(Id,CoreExpr)]
558

559 560 561 562
mkSelectorBinds ticks (L _ (VarPat v)) val_expr
  = return [(v, case ticks of
                  [t] -> mkOptTickBox t val_expr
                  _   -> val_expr)]
sof's avatar
sof committed
563

564
mkSelectorBinds ticks pat val_expr
565 566 567 568 569 570 571
  | null binders 
  = return []

  | isSingleton binders || is_simple_lpat pat
    -- See Note [mkSelectorBinds]
  = do { val_var <- newSysLocalDs (hsLPatType pat)
        -- Make up 'v' in Note [mkSelectorBinds]
572 573 574 575 576 577 578 579 580 581 582 583 584 585
        -- 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.

        -- 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
586 587
       ; err_expr <- mkErrorAppDs iRREFUT_PAT_ERROR_ID  unitTy (ppr pat)
       ; err_var <- newSysLocalDs unitTy
588
       ; binds <- zipWithM (mk_bind val_var err_var) ticks' binders
589 590 591 592 593 594 595 596
       ; return ( (val_var, val_expr) : 
                  (err_var, err_expr) :
                  binds ) }

  | otherwise
  = do { error_expr <- mkErrorAppDs iRREFUT_PAT_ERROR_ID   tuple_ty (ppr pat)
       ; tuple_expr <- matchSimply val_expr PatBindRhs pat local_tuple error_expr
       ; tuple_var <- newSysLocalDs tuple_ty
597 598 599 600 601
       ; let mk_tup_bind tick binder
              = (binder, mkOptTickBox tick $
                            mkTupleSelector local_binders binder
                                            tuple_var (Var tuple_var))
       ; return ( (tuple_var, tuple_expr) : zipWith mk_tup_bind ticks' binders ) }
602
  where
603
    binders       = collectPatBinders pat
604 605 606
    ticks'        = ticks ++ repeat Nothing

    local_binders = map localiseId binders      -- See Note [Localise pattern binders]
607 608
    local_tuple   = mkBigCoreVarTup binders
    tuple_ty      = exprType local_tuple
609

610
    mk_bind scrut_var err_var tick bndr_var = do
611
    -- (mk_bind sv err_var) generates
612
    --          bv = case sv of { pat -> bv; other -> coerce (type-of-bv) err_var }
613
    -- Remember, pat binds bv
614 615
        rhs_expr <- matchSimply (Var scrut_var) PatBindRhs pat
                                (Var bndr_var) error_expr
616
        return (bndr_var, mkOptTickBox tick rhs_expr)
617
      where
618
        error_expr = mkCast (Var err_var) co
619
        co         = mkUnsafeCo (exprType (Var err_var)) (idType bndr_var)
620

621 622
    is_simple_lpat p = is_simple_pat (unLoc p)

623 624 625
    is_simple_pat (TuplePat ps Boxed _) = all is_triv_lpat ps
    is_simple_pat pat@(ConPatOut{})     =  isProductTyCon (dataConTyCon (unLoc (pat_con pat)))
                                        && all is_triv_lpat (hsConPatArgs (pat_args pat))
626 627 628
    is_simple_pat (VarPat _)                   = True
    is_simple_pat (ParPat p)                   = is_simple_lpat p
    is_simple_pat _                                    = False
629

630 631
    is_triv_lpat p = is_triv_pat (unLoc p)

632
    is_triv_pat (VarPat _)  = True
633
    is_triv_pat (WildPat _) = True
634
    is_triv_pat (ParPat p)  = is_triv_lpat p
635 636 637
    is_triv_pat _           = False
\end{code}

638 639 640
Creating big tuples and their types for full Haskell expressions.
They work over *Ids*, and create tuples replete with their types,
which is whey they are not in HsUtils.
641 642 643

\begin{code}
mkLHsPatTup :: [LPat Id] -> LPat Id
644
mkLHsPatTup []     = noLoc $ mkVanillaTuplePat [] Boxed
645
mkLHsPatTup [lpat] = lpat
646 647
mkLHsPatTup lpats  = L (getLoc (head lpats)) $ 
		     mkVanillaTuplePat lpats Boxed
648

649 650 651 652 653 654
mkLHsVarPatTup :: [Id] -> LPat Id
mkLHsVarPatTup bs  = mkLHsPatTup (map nlVarPat bs)

mkVanillaTuplePat :: [OutPat Id] -> Boxity -> Pat Id
-- A vanilla tuple pattern simply gets its type from its sub-patterns
mkVanillaTuplePat pats box 
batterseapower's avatar
batterseapower committed
655
  = TuplePat pats box (mkTupleTy (boxityNormalTupleSort box) (map hsLPatType pats))
656

657 658 659 660 661
-- The Big equivalents for the source tuple expressions
mkBigLHsVarTup :: [Id] -> LHsExpr Id
mkBigLHsVarTup ids = mkBigLHsTup (map nlHsVar ids)

mkBigLHsTup :: [LHsExpr Id] -> LHsExpr Id
662
mkBigLHsTup = mkChunkified mkLHsTupleExpr
663 664 665 666 667 668

-- The Big equivalents for the source tuple patterns
mkBigLHsVarPatTup :: [Id] -> LPat Id
mkBigLHsVarPatTup bs = mkBigLHsPatTup (map nlVarPat bs)

mkBigLHsPatTup :: [LPat Id] -> LPat Id
669
mkBigLHsPatTup = mkChunkified mkLHsPatTup
670 671
\end{code}

672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
%************************************************************************
%*									*
\subsection[mkFailurePair]{Code for pattern-matching and other failures}
%*									*
%************************************************************************

Generally, we handle pattern matching failure like this: let-bind a
fail-variable, and use that variable if the thing fails:
\begin{verbatim}
	let fail.33 = error "Help"
	in
	case x of
		p1 -> ...
		p2 -> fail.33
		p3 -> fail.33
		p4 -> ...
\end{verbatim}
Then
\begin{itemize}
\item
692
If the case can't fail, then there'll be no mention of @fail.33@, and the
693 694 695 696 697 698 699 700 701 702
simplifier will later discard it.

\item
If it can fail in only one way, then the simplifier will inline it.

\item
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
703
unboxed type.  Then the type of @fail.33@ is unboxed too, and
704 705 706 707 708 709 710
there is every chance that someone will change the let into a case:
\begin{verbatim}
	case error "Help" of
	  fail.33 -> case ....
\end{verbatim}

which is of course utterly wrong.  Rather than drop the condition that
711
only boxed types can be let-bound, we just turn the fail into a function
712 713
for the primitive case:
\begin{verbatim}
714
	let fail.33 :: Void -> Int#
715 716 717 718
	    fail.33 = \_ -> error "Help"
	in
	case x of
		p1 -> ...
719 720
		p2 -> fail.33 void
		p3 -> fail.33 void
721 722 723
		p4 -> ...
\end{verbatim}

724
Now @fail.33@ is a function, so it can be let-bound.
725 726

\begin{code}
727 728
mkFailurePair :: CoreExpr	-- Result type of the whole case expression
	      -> DsM (CoreBind,	-- Binds the newly-created fail variable
729 730 731
				-- to \ _ -> expression
		      CoreExpr)	-- Fail variable applied to realWorld#
-- See Note [Failure thunks and CPR]
732
mkFailurePair expr
733 734 735 736
  = do { fail_fun_var <- newFailLocalDs (realWorldStatePrimTy `mkFunTy` ty)
       ; fail_fun_arg <- newSysLocalDs realWorldStatePrimTy
       ; return (NonRec fail_fun_var (Lam fail_fun_arg expr),
                 App (Var fail_fun_var) (Var realWorldPrimId)) }
737
  where
738
    ty = exprType expr
739 740
\end{code}

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
Note [Failure thunks and CPR]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we make a failure point we ensure that it
does not look like a thunk. Example:

   let fail = \rw -> error "urk"
   in case x of 
        [] -> fail realWorld#
        (y:ys) -> case ys of
                    [] -> fail realWorld#  
                    (z:zs) -> (y,z)

Reason: we know that a failure point is always a "join point" and is
entered at most once.  Adding a dummy 'realWorld' token argument makes
it clear that sharing is not an issue.  And that in turn makes it more
CPR-friendly.  This matters a lot: if you don't get it right, you lose
the tail call property.  For example, see Trac #3403.

andy@galois.com's avatar
andy@galois.com committed
759
\begin{code}
760 761 762
mkOptTickBox :: Maybe (Tickish Id) -> CoreExpr -> CoreExpr
mkOptTickBox Nothing e        = e
mkOptTickBox (Just tickish) e = Tick tickish e
andy@galois.com's avatar
andy@galois.com committed
763 764 765

mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr
mkBinaryTickBox ixT ixF e = do
766
       uq <- newUnique 	
767
       this_mod <- getModule
768 769 770 771 772
       let bndr1 = mkSysLocal (fsLit "t1") uq boolTy
       let
           falseBox = Tick (HpcTick this_mod ixF) (Var falseDataConId)
           trueBox  = Tick (HpcTick this_mod ixT) (Var trueDataConId)
       --
773 774 775 776
       return $ Case e bndr1 boolTy
                       [ (DataAlt falseDataCon, [], falseBox)
                       , (DataAlt trueDataCon,  [], trueBox)
                       ]
777
\end{code}