Utils.hs 36.2 KB
Newer Older
Austin Seipp's avatar
Austin Seipp committed
1
2
3
4
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

Simon Marlow's avatar
Simon Marlow committed
5
6

Utilities for desugaring
7
8

This module exports some utility functions of no great interest.
Austin Seipp's avatar
Austin Seipp committed
9
-}
10

11
{-# LANGUAGE CPP #-}
12
{-# LANGUAGE FlexibleContexts #-}
13
{-# LANGUAGE LambdaCase #-}
14
{-# LANGUAGE TypeFamilies #-}
15
{-# LANGUAGE ViewPatterns #-}
Ian Lynagh's avatar
Ian Lynagh committed
16

17
-- | Utility functions for constructing Core syntax, principally for desugaring
18
module GHC.HsToCore.Utils (
19
20
        EquationInfo(..),
        firstPat, shiftEqns,
21

22
        MatchResult'(..), MatchResult, CaseAlt(..),
23
24
        cantFailMatchResult, alwaysFailMatchResult,
        extractMatchResult, combineMatchResults,
John Ericson's avatar
John Ericson committed
25
        adjustMatchResultDs,
26
        shareFailureHandler,
27
28
29
30
        mkCoLetMatchResult, mkViewMatchResult, mkGuardedMatchResult,
        matchCanFail, mkEvalMatchResult,
        mkCoPrimCaseMatchResult, mkCoAlgCaseMatchResult, mkCoSynCaseMatchResult,
        wrapBind, wrapBinds,
31

32
        mkErrorAppDs, mkCoreAppDs, mkCoreAppsDs, mkCastDs,
33
34
35
36

        seqVar,

        -- LHs tuples
37
        mkLHsPatTup, mkVanillaTuplePat,
Simon Marlow's avatar
Simon Marlow committed
38
        mkBigLHsVarTupId, mkBigLHsTupId, mkBigLHsVarPatTupId, mkBigLHsPatTupId,
39
40
41

        mkSelectorBinds,

42
        selectSimpleMatchVarL, selectMatchVars, selectMatchVar,
Brian Foley's avatar
Brian Foley committed
43
        mkOptTickBox, mkBinaryTickBox, decideBangHood,
44
        isTrueLHsExpr
45
46
    ) where

47
48
#include "HsVersions.h"

49
50
import GhcPrelude

51
52
import {-# SOURCE #-} GHC.HsToCore.Match ( matchSimply )
import {-# SOURCE #-} GHC.HsToCore.Expr  ( dsLExpr )
53

Sylvain Henry's avatar
Sylvain Henry committed
54
import GHC.Hs
Sylvain Henry's avatar
Sylvain Henry committed
55
56
import GHC.Tc.Utils.Zonk
import GHC.Tc.Utils.TcType( tcSplitTyConApp )
Sylvain Henry's avatar
Sylvain Henry committed
57
import GHC.Core
58
import GHC.HsToCore.Monad
59

Sylvain Henry's avatar
Sylvain Henry committed
60
61
import GHC.Core.Utils
import GHC.Core.Make
Sylvain Henry's avatar
Sylvain Henry committed
62
63
64
import GHC.Types.Id.Make
import GHC.Types.Id
import GHC.Types.Literal
Sylvain Henry's avatar
Sylvain Henry committed
65
66
67
68
69
import GHC.Core.TyCon
import GHC.Core.DataCon
import GHC.Core.PatSyn
import GHC.Core.Type
import GHC.Core.Coercion
Sylvain Henry's avatar
Sylvain Henry committed
70
71
import GHC.Builtin.Types.Prim
import GHC.Builtin.Types
Sylvain Henry's avatar
Sylvain Henry committed
72
import GHC.Types.Basic
Sylvain Henry's avatar
Sylvain Henry committed
73
import GHC.Core.ConLike
Sylvain Henry's avatar
Sylvain Henry committed
74
75
76
import GHC.Types.Unique.Set
import GHC.Types.Unique.Supply
import GHC.Types.Module
Sylvain Henry's avatar
Sylvain Henry committed
77
import GHC.Builtin.Names
Sylvain Henry's avatar
Sylvain Henry committed
78
import GHC.Types.Name( isInternalName )
sof's avatar
sof committed
79
import Outputable
Sylvain Henry's avatar
Sylvain Henry committed
80
import GHC.Types.SrcLoc
Simon Marlow's avatar
Simon Marlow committed
81
import Util
Sylvain Henry's avatar
Sylvain Henry committed
82
import GHC.Driver.Session
83
import FastString
84
import qualified GHC.LanguageExtensions as LangExt
85

Sylvain Henry's avatar
Sylvain Henry committed
86
import GHC.Tc.Types.Evidence
Gergő Érdi's avatar
Gergő Érdi committed
87

88
import Control.Monad    ( zipWithM )
89
import Data.List.NonEmpty (NonEmpty(..))
90
import Data.Maybe (maybeToList)
91
import qualified Data.List.NonEmpty as NEL
sof's avatar
sof committed
92

Austin Seipp's avatar
Austin Seipp committed
93
94
95
{-
************************************************************************
*                                                                      *
96
\subsection{ Selecting match variables}
Austin Seipp's avatar
Austin Seipp committed
97
98
*                                                                      *
************************************************************************
sof's avatar
sof committed
99
100
101
102
103

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.
Austin Seipp's avatar
Austin Seipp committed
104
-}
sof's avatar
sof committed
105

106
selectSimpleMatchVarL :: LPat GhcTc -> DsM Id
107
-- Postcondition: the returned Id has an Internal Name
108
selectSimpleMatchVarL pat = selectMatchVar (unLoc pat)
109
110
111
112

-- (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.
113
114
115
--
-- OLD, but interesting note:
--    But even if it is a variable, its type might not match.  Consider
116
117
118
--      data T a where
--        T1 :: Int -> T Int
--        T2 :: a   -> T a
119
--
120
121
122
--      f :: T a -> a -> Int
--      f (T1 i) (x::Int) = x
--      f (T2 i) (y::a)   = 0
123
124
125
--    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

126
selectMatchVars :: [Pat GhcTc] -> DsM [Id]
127
-- Postcondition: the returned Ids have Internal Names
128
129
selectMatchVars ps = mapM selectMatchVar ps

130
selectMatchVar :: Pat GhcTc -> DsM Id
131
-- Postcondition: the returned Id has an Internal Name
132
133
134
135
selectMatchVar (BangPat _ pat) = selectMatchVar (unLoc pat)
selectMatchVar (LazyPat _ pat) = selectMatchVar (unLoc pat)
selectMatchVar (ParPat _ pat)  = selectMatchVar (unLoc pat)
selectMatchVar (VarPat _ var)  = return (localiseId (unLoc var))
136
                                  -- Note [Localise pattern binders]
137
138
selectMatchVar (AsPat _ var _) = return (unLoc var)
selectMatchVar other_pat       = newSysLocalDsNoLP (hsPatType other_pat)
139
                                  -- OK, better make up one...
sof's avatar
sof committed
140

141
142
{- Note [Localise pattern binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
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
160
of is tc003 compiled with the 'hpc' way -- but that only makes it
161
162
163
164
165
166
167
168
169
170
171
172
173
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}
Sylvain Henry's avatar
Sylvain Henry committed
174
In fact, even GHC.Core.Subst.simplOptExpr will do this, and simpleOptExpr
175
176
177
runs on the output of the desugarer, so all is well by the end of
the desugaring pass.

178
See also Note [MatchIds] in GHC.HsToCore.Match
sof's avatar
sof committed
179

Austin Seipp's avatar
Austin Seipp committed
180
181
182
183
184
************************************************************************
*                                                                      *
* type synonym EquationInfo and access functions for its pieces        *
*                                                                      *
************************************************************************
185
186
187
188
\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.
Austin Seipp's avatar
Austin Seipp committed
189
-}
190

191
firstPat :: EquationInfo -> Pat GhcTc
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
192
firstPat eqn = ASSERT( notNull (eqn_pats eqn) ) head (eqn_pats eqn)
193

194
shiftEqns :: Functor f => f EquationInfo -> f EquationInfo
195
-- Drop the first pattern in each equation
196
shiftEqns = fmap $ \eqn -> eqn { eqn_pats = tail (eqn_pats eqn) }
197

Austin Seipp's avatar
Austin Seipp committed
198
-- Functions on MatchResults
199

200
matchCanFail :: MatchResult' a -> Bool
201
202
matchCanFail (MR_Fallible {})  = True
matchCanFail (MR_Infallible {}) = False
203

204
alwaysFailMatchResult :: MatchResult
205
alwaysFailMatchResult = MR_Fallible $ \fail -> return fail
206

207
cantFailMatchResult :: CoreExpr -> MatchResult
208
cantFailMatchResult expr = MR_Infallible $ return expr
209

210
extractMatchResult :: MatchResult -> CoreExpr -> DsM CoreExpr
211
212
213
214
extractMatchResult match_result failure_expr =
  runMatchResult
    failure_expr
    (shareFailureHandler match_result)
215

216
combineMatchResults :: MatchResult -> MatchResult -> MatchResult
217
combineMatchResults match_result1@(MR_Infallible _) _
218
  = match_result1
219
220
221
222
223
224
225
226
combineMatchResults match_result1 match_result2 =
  -- if the first pattern needs a failure handler (i.e. if it is is fallible),
  -- make it let-bind it bind it with `shareFailureHandler`.
  case shareFailureHandler match_result1 of
    MR_Infallible _ -> match_result1
    MR_Fallible body_fn1 -> MR_Fallible $ \fail_expr ->
      -- Before actually failing, try the next match arm.
      body_fn1 =<< runMatchResult fail_expr match_result2
227

228
229
230
231
232
233
adjustMatchResultDs :: (a -> DsM b) -> MatchResult' a -> MatchResult' b
adjustMatchResultDs encl_fn = \case
  MR_Infallible body_fn -> MR_Infallible $
    encl_fn =<< body_fn
  MR_Fallible body_fn -> MR_Fallible $ \fail ->
    encl_fn =<< body_fn fail
234

235
236
237
wrapBinds :: [(Var,Var)] -> CoreExpr -> CoreExpr
wrapBinds [] e = e
wrapBinds ((new,old):prs) e = wrapBind new old (wrapBinds prs e)
238

239
wrapBind :: Var -> Var -> CoreExpr -> CoreExpr
240
241
wrapBind new old body   -- NB: this function must deal with term
  | new==old    = body  -- variables, type variables or coercion variables
242
  | otherwise   = Let (NonRec new (varToCoreExpr old)) body
243

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
244
seqVar :: Var -> CoreExpr -> CoreExpr
245
seqVar var body = mkDefaultCase (Var var) var body
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
246

247
mkCoLetMatchResult :: CoreBind -> MatchResult -> MatchResult
John Ericson's avatar
John Ericson committed
248
mkCoLetMatchResult bind = fmap (mkCoreLet bind)
249

250
251
252
-- (mkViewMatchResult var' viewExpr mr) makes the expression
-- let var' = viewExpr in mr
mkViewMatchResult :: Id -> CoreExpr -> MatchResult -> MatchResult
John Ericson's avatar
John Ericson committed
253
mkViewMatchResult var' viewExpr = fmap $ mkCoreLet $ NonRec var' viewExpr
254

255
mkEvalMatchResult :: Id -> Type -> MatchResult -> MatchResult
John Ericson's avatar
John Ericson committed
256
257
mkEvalMatchResult var ty = fmap $ \e ->
  Case (Var var) var ty [(DEFAULT, [], e)]
258
259

mkGuardedMatchResult :: CoreExpr -> MatchResult -> MatchResult
260
261
262
mkGuardedMatchResult pred_expr mr = MR_Fallible $ \fail -> do
  body <- runMatchResult fail mr
  return (mkIfThenElse pred_expr body fail)
263

264
mkCoPrimCaseMatchResult :: Id                  -- Scrutinee
265
266
267
                        -> Type                      -- Type of the case
                        -> [(Literal, MatchResult)]  -- Alternatives
                        -> MatchResult               -- Literals are all unlifted
268
mkCoPrimCaseMatchResult var ty match_alts
269
  = MR_Fallible mk_case
270
  where
271
272
273
    mk_case fail = do
        alts <- mapM (mk_alt fail) sorted_alts
        return (Case (Var var) var ty ((DEFAULT, [], fail) : alts))
274

275
    sorted_alts = sortWith fst match_alts       -- Right order for a Case
276
    mk_alt fail (lit, mr)
277
       = ASSERT( not (litIsLifted lit) )
278
         do body <- runMatchResult fail mr
279
            return (LitAlt lit, [], body)
280

Gergő Érdi's avatar
Gergő Érdi committed
281
data CaseAlt a = MkCaseAlt{ alt_pat :: a,
282
                            alt_bndrs :: [Var],
Gergő Érdi's avatar
Gergő Érdi committed
283
284
                            alt_wrapper :: HsWrapper,
                            alt_result :: MatchResult }
285

286
mkCoAlgCaseMatchResult
287
288
289
  :: Id -- ^ Scrutinee
  -> Type -- ^ Type of exp
  -> NonEmpty (CaseAlt DataCon) -- ^ Alternatives (bndrs *include* tyvars, dicts)
290
  -> MatchResult
291
mkCoAlgCaseMatchResult var ty match_alts
Gergő Érdi's avatar
Gergő Érdi committed
292
  | isNewtype  -- Newtype case; use a let
293
  = ASSERT( null match_alts_tail && null (tail arg_ids1) )
294
    mkCoLetMatchResult (NonRec arg_id1 newtype_rhs) match_result1
295

Gergő Érdi's avatar
Gergő Érdi committed
296
297
  | otherwise
  = mkDataConCase var ty match_alts
298
  where
Gergő Érdi's avatar
Gergő Érdi committed
299
300
    isNewtype = isNewTyCon (dataConTyCon (alt_pat alt1))

301
302
        -- [Interesting: because of GADTs, we can't rely on the type of
        --  the scrutinised Id to be sufficiently refined to have a TyCon in it]
303

304
305
    alt1@MkCaseAlt{ alt_bndrs = arg_ids1, alt_result = match_result1 } :| match_alts_tail
      = match_alts
Gergő Érdi's avatar
Gergő Érdi committed
306
307
308
    -- Stuff for newtype
    arg_id1       = ASSERT( notNull arg_ids1 ) head arg_ids1
    var_ty        = idType var
309
310
    (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
311
    newtype_rhs = unwrapNewTypeBody tc ty_args (Var var)
chak's avatar
chak committed
312

Gergő Érdi's avatar
Gergő Érdi committed
313
mkCoSynCaseMatchResult :: Id -> Type -> CaseAlt PatSyn -> MatchResult
314
mkCoSynCaseMatchResult var ty alt = MR_Fallible $ mkPatSynCase var ty alt
Gergő Érdi's avatar
Gergő Érdi committed
315
316
317

mkPatSynCase :: Id -> Type -> CaseAlt PatSyn -> CoreExpr -> DsM CoreExpr
mkPatSynCase var ty alt fail = do
318
    matcher <- dsLExpr $ mkLHsWrap wrapper $
319
                         nlHsTyApp matcher [getRuntimeRep ty, ty]
320
    cont <- mkCoreLams bndrs <$> runMatchResult fail match_result
321
    return $ mkCoreAppsDs (text "patsyn" <+> ppr var) matcher [Var var, ensure_unstrict cont, Lam voidArgId fail]
Gergő Érdi's avatar
Gergő Érdi committed
322
323
324
325
326
  where
    MkCaseAlt{ alt_pat = psyn,
               alt_bndrs = bndrs,
               alt_wrapper = wrapper,
               alt_result = match_result} = alt
327
    (matcher, needs_void_lam) = patSynMatcher psyn
Gergő Érdi's avatar
Gergő Érdi committed
328

Sylvain Henry's avatar
Sylvain Henry committed
329
    -- See Note [Matchers and builders for pattern synonyms] in GHC.Core.PatSyn
330
    -- on these extra Void# arguments
331
332
    ensure_unstrict cont | needs_void_lam = Lam voidArgId cont
                         | otherwise      = cont
333

334
mkDataConCase :: Id -> Type -> NonEmpty (CaseAlt DataCon) -> MatchResult
335
336
337
mkDataConCase var ty alts@(alt1 :| _)
    = liftA2 mk_case mk_default mk_alts
    -- The liftA2 combines the failability of all the alternatives and the default
Gergő Érdi's avatar
Gergő Érdi committed
338
339
340
341
342
  where
    con1          = alt_pat alt1
    tycon         = dataConTyCon con1
    data_cons     = tyConDataCons tycon

343
344
    sorted_alts :: [ CaseAlt DataCon ]
    sorted_alts  = sortWith (dataConTag . alt_pat) $ NEL.toList alts
Gergő Érdi's avatar
Gergő Érdi committed
345
346
347
348
349

    var_ty       = idType var
    (_, ty_args) = tcSplitTyConApp var_ty -- Don't look through newtypes
                                          -- (not that splitTyConApp does, these days)

350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
    mk_case :: Maybe CoreAlt -> [CoreAlt] -> CoreExpr
    mk_case def alts = mkWildCase (Var var) (idType var) ty $
      maybeToList def ++ alts

    mk_alts :: MatchResult' [CoreAlt]
    mk_alts = traverse mk_alt sorted_alts

    mk_alt :: CaseAlt DataCon -> MatchResult' CoreAlt
    mk_alt MkCaseAlt { alt_pat = con
                     , alt_bndrs = args
                     , alt_result = match_result } =
      flip adjustMatchResultDs match_result $ \body -> do
        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)

    mk_default :: MatchResult' (Maybe CoreAlt)
    mk_default
      | exhaustive_case = MR_Infallible $ return Nothing
      | otherwise       = MR_Fallible $ \fail -> return $ Just (DEFAULT, [], fail)

    mentioned_constructors = mkUniqSet $ map alt_pat sorted_alts
Gergő Érdi's avatar
Gergő Érdi committed
375
376
377
378
    un_mentioned_constructors
        = mkUniqSet data_cons `minusUniqSet` mentioned_constructors
    exhaustive_case = isEmptyUniqSet un_mentioned_constructors

Austin Seipp's avatar
Austin Seipp committed
379
380
381
{-
************************************************************************
*                                                                      *
382
\subsection{Desugarer's versions of some Core functions}
Austin Seipp's avatar
Austin Seipp committed
383
384
385
*                                                                      *
************************************************************************
-}
386

387
388
389
390
mkErrorAppDs :: Id              -- The error function
             -> Type            -- Type to which it should be applied
             -> SDoc            -- The error message string to pass
             -> DsM CoreExpr
391

392
393
mkErrorAppDs err_id ty msg = do
    src_loc <- getSrcSpanDs
Ian Lynagh's avatar
Ian Lynagh committed
394
    dflags <- getDynFlags
395
    let
396
        full_msg = showSDoc dflags (hcat [ppr src_loc, vbar, msg])
Sylvain Henry's avatar
Sylvain Henry committed
397
398
        core_msg = Lit (mkLitString full_msg)
        -- mkLitString returns a result of type String#
399
    return (mkApps (Var err_id) [Type (getRuntimeRep ty), Type ty, core_msg])
400

Austin Seipp's avatar
Austin Seipp committed
401
{-
402
403
404
405
406
407
408
409
410
411
412
413
'mkCoreAppDs' and 'mkCoreAppsDs' handle the special-case desugaring of 'seq'.

Note [Desugaring seq]
~~~~~~~~~~~~~~~~~~~~~

There are a few subtleties in the desugaring of `seq`:

 1. (as described in #1031)

    Consider,
       f x y = x `seq` (y `seq` (# x,y #))

Sylvain Henry's avatar
Sylvain Henry committed
414
    The [Core let/app invariant] means that, other things being equal, because
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
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
468
469
470
471
472
    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 #)

 2. (as described in #2273)

    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
    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:
       let chp = case b of { True -> fst x; False -> 0 }
       case chp of chp { I# -> ...chp... }
    And now all is well.

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

 3. (as described in #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'.
Austin Seipp's avatar
Austin Seipp committed
473
-}
474

475
-- NB: Make sure the argument is not levity polymorphic
476
mkCoreAppDs  :: SDoc -> CoreExpr -> CoreExpr -> CoreExpr
477
478
mkCoreAppDs _ (Var f `App` Type _r `App` Type ty1 `App` Type ty2 `App` arg1) arg2
  | f `hasKey` seqIdKey            -- Note [Desugaring seq], points (1) and (2)
479
480
481
  = Case arg1 case_bndr ty2 [(DEFAULT,[],arg2)]
  where
    case_bndr = case arg1 of
482
                   Var v1 | isInternalName (idName v1)
483
                          -> v1        -- Note [Desugaring seq], points (2) and (3)
484
                   _      -> mkWildValBinder ty1
485

Sylvain Henry's avatar
Sylvain Henry committed
486
mkCoreAppDs s fun arg = mkCoreApp s fun arg  -- The rest is done in GHC.Core.Make
487

488
-- NB: No argument can be levity polymorphic
489
mkCoreAppsDs :: SDoc -> CoreExpr -> [CoreExpr] -> CoreExpr
490
mkCoreAppsDs s fun args = foldl' (mkCoreAppDs s) fun args
491

492
mkCastDs :: CoreExpr -> Coercion -> CoreExpr
Sylvain Henry's avatar
Sylvain Henry committed
493
-- We define a desugarer-specific version of GHC.Core.Utils.mkCast,
494
495
496
497
498
499
-- because in the immediate output of the desugarer, we can have
-- apparently-mis-matched coercions:  E.g.
--     let a = b
--     in (x :: a) |> (co :: b ~ Int)
-- Lint know about type-bindings for let and does not complain
-- So here we do not make the assertion checks that we make in
Sylvain Henry's avatar
Sylvain Henry committed
500
-- GHC.Core.Utils.mkCast; and we do less peephole optimisation too
501
502
503
mkCastDs e co | isReflCo co = e
              | otherwise   = Cast e co

Austin Seipp's avatar
Austin Seipp committed
504
505
506
{-
************************************************************************
*                                                                      *
507
               Tuples and selector bindings
Austin Seipp's avatar
Austin Seipp committed
508
509
*                                                                      *
************************************************************************
510
511
512

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
Note [mkSelectorBinds]
~~~~~~~~~~~~~~~~~~~~~~
529
530
531
532
533
534
mkSelectorBinds is used to desugar a pattern binding {p = e},
in a binding group:
  let { ...; p = e; ... } in body
where p binds x,y (this list of binders can be empty).
There are two cases.

535
536
537
538
539
540
------ Special case (A) -------
  For a pattern that is just a variable,
     let !x = e in body
  ==>
     let x = e in x `seq` body
  So we return the binding, with 'x' as the variable to seq.
541

542
------ Special case (B) -------
543
544
545
546
547
548
549
550
551
552
553
  For a pattern that is essentially just a tuple:
      * A product type, so cannot fail
      * Only one level, so that
          - generating multiple matches is fine
          - seq'ing it evaluates the same as matching it
  Then instead we generate
       { v = e
       ; x = case v of p -> x
       ; y = case v of p -> y }
  with 'v' as the variable to force

554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
------ General case (C) -------
  In the general case we generate these bindings:
       let { ...; p = e; ... } in body
  ==>
       let { t = case e of p -> (x,y)
           ; x = case t of (x,y) -> x
           ; y = case t of (x,y) -> y }
       in t `seq` body

  Note that we return 't' as the variable to force if the pattern
  is strict (i.e. with -XStrict or an outermost-bang-pattern)

  Note that (A) /includes/ the situation where

   * The pattern binds exactly one variable
        let !(Just (Just x) = e in body
     ==>
       let { t = case e of Just (Just v) -> Unit v
           ; v = case t of Unit v -> v }
       in t `seq` body
Sylvain Henry's avatar
Sylvain Henry committed
574
    The 'Unit' is a one-tuple; see Note [One-tuples] in GHC.Builtin.Types
575
576
577
578
579
580
581
582
583
584
585
    Note that forcing 't' makes the pattern match happen,
    but does not force 'v'.

  * The pattern binds no variables
        let !(True,False) = e in body
    ==>
        let t = case e of (True,False) -> ()
        in t `seq` body


------ Examples ----------
586
587
588
589
590
591
592
593
594
  *   !(_, (_, a)) = e
    ==>
      t = case e of (_, (_, a)) -> Unit a
      a = case t of Unit a -> a

    Note that
     - Forcing 't' will force the pattern to match fully;
       e.g. will diverge if (snd e) is bottom
     - But 'a' itself is not forced; it is wrapped in a one-tuple
Sylvain Henry's avatar
Sylvain Henry committed
595
       (see Note [One-tuples] in GHC.Builtin.Types)
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656

  *   !(Just x) = e
    ==>
      t = case e of Just x -> Unit x
      x = case t of Unit x -> x

    Again, forcing 't' will fail if 'e' yields Nothing.

Note that even though this is rather general, the special cases
work out well:

* One binder, not -XStrict:

    let Just (Just v) = e in body
  ==>
    let t = case e of Just (Just v) -> Unit v
        v = case t of Unit v -> v
    in body
  ==>
    let v = case (case e of Just (Just v) -> Unit v) of
              Unit v -> v
    in body
  ==>
    let v = case e of Just (Just v) -> v
    in body

* Non-recursive, -XStrict
     let p = e in body
  ==>
     let { t = case e of p -> (x,y)
         ; x = case t of (x,y) -> x
         ; y = case t of (x,y) -> x }
     in t `seq` body
  ==> {inline seq, float x,y bindings inwards}
     let t = case e of p -> (x,y) in
     case t of t' ->
     let { x = case t' of (x,y) -> x
         ; y = case t' of (x,y) -> x } in
     body
  ==> {inline t, do case of case}
     case e of p ->
     let t = (x,y) in
     let { x = case t' of (x,y) -> x
         ; y = case t' of (x,y) -> x } in
     body
  ==> {case-cancellation, drop dead code}
     case e of p -> body

* Special case (B) is there to avoid fruitlessly taking the tuple
  apart and rebuilding it. For example, consider
     { K x y = e }
  where K is a product constructor.  Then general case (A) does:
     { t = case e of K x y -> (x,y)
     ; x = case t of (x,y) -> x
     ; y = case t of (x,y) -> y }
  In the lazy case we can't optimise out this fruitless taking apart
  and rebuilding.  Instead (B) builds
     { v = e
     ; x = case v of K x y -> x
     ; y = case v of K x y -> y }
  which is better.
Austin Seipp's avatar
Austin Seipp committed
657
-}
658

659
mkSelectorBinds :: [[Tickish Id]] -- ^ ticks to add, possibly
660
                -> LPat GhcTc     -- ^ The pattern
661
                -> CoreExpr       -- ^ Expression to which the pattern is bound
662
                -> DsM (Id,[(Id,CoreExpr)])
663
                -- ^ Id the rhs is bound to, for desugaring strict
664
                -- binds (see Note [Desugar Strict binds] in GHC.HsToCore.Binds)
665
666
                -- and all the desugared binds

667
mkSelectorBinds ticks pat val_expr
668
  | L _ (VarPat _ (L _ v)) <- pat'     -- Special case (A)
669
670
671
  = return (v, [(v, val_expr)])

  | is_flat_prod_lpat pat'           -- Special case (B)
672
  = do { let pat_ty = hsLPatType pat'
Richard Eisenberg's avatar
Richard Eisenberg committed
673
       ; val_var <- newSysLocalDsNoLP pat_ty
674

675
       ; let mk_bind tick bndr_var
676
677
               -- (mk_bind sv bv)  generates  bv = case sv of { pat -> bv }
               -- Remember, 'pat' binds 'bv'
678
               = do { rhs_expr <- matchSimply (Var val_var) PatBindRhs pat'
679
680
681
682
683
684
685
686
                                       (Var bndr_var)
                                       (Var bndr_var)  -- Neat hack
                      -- Neat hack: since 'pat' can't fail, the
                      -- "fail-expr" passed to matchSimply is not
                      -- used. But it /is/ used for its type, and for
                      -- that bndr_var is just the ticket.
                    ; return (bndr_var, mkOptTickBox tick rhs_expr) }

687
       ; binds <- zipWithM mk_bind ticks' binders
688
689
       ; return ( val_var, (val_var, val_expr) : binds) }

690
  | otherwise                          -- General case (C)
691
  = do { tuple_var  <- newSysLocalDs tuple_ty
692
       ; error_expr <- mkErrorAppDs pAT_ERROR_ID tuple_ty (ppr pat')
693
       ; tuple_expr <- matchSimply val_expr PatBindRhs pat
694
                                   local_tuple error_expr
695
       ; let mk_tup_bind tick binder
696
               = (binder, mkOptTickBox tick $
697
698
699
700
                          mkTupleSelector1 local_binders binder
                                           tuple_var (Var tuple_var))
             tup_binds = zipWith mk_tup_bind ticks' binders
       ; return (tuple_var, (tuple_var, tuple_expr) : tup_binds) }
701
  where
702
703
704
705
706
    pat' = strip_bangs pat
           -- Strip the bangs before looking for case (A) or (B)
           -- The incoming pattern may well have a bang on it

    binders = collectPatBinders pat'
707
    ticks'  = ticks ++ repeat []
708
709

    local_binders = map localiseId binders      -- See Note [Localise pattern binders]
710
    local_tuple   = mkBigCoreVarTup1 binders
711
    tuple_ty      = exprType local_tuple
712

713
strip_bangs :: LPat (GhcPass p) -> LPat (GhcPass p)
714
-- Remove outermost bangs and parens
715
716
717
strip_bangs (L _ (ParPat _ p))  = strip_bangs p
strip_bangs (L _ (BangPat _ p)) = strip_bangs p
strip_bangs lp                  = lp
718

719
720
is_flat_prod_lpat :: LPat (GhcPass p) -> Bool
is_flat_prod_lpat = is_flat_prod_pat . unLoc
721

722
is_flat_prod_pat :: Pat (GhcPass p) -> Bool
723
724
is_flat_prod_pat (ParPat _ p)          = is_flat_prod_lpat p
is_flat_prod_pat (TuplePat _ ps Boxed) = all is_triv_lpat ps
725
is_flat_prod_pat (ConPatOut { pat_con  = L _ pcon
726
                            , pat_args = ps})
727
728
729
730
  | RealDataCon con <- pcon
  , isProductTyCon (dataConTyCon con)
  = all is_triv_lpat (hsConPatArgs ps)
is_flat_prod_pat _ = False
731

732
733
is_triv_lpat :: LPat (GhcPass p) -> Bool
is_triv_lpat = is_triv_pat . unLoc
734

735
is_triv_pat :: Pat (GhcPass p) -> Bool
736
737
738
739
is_triv_pat (VarPat {})  = True
is_triv_pat (WildPat{})  = True
is_triv_pat (ParPat _ p) = is_triv_lpat p
is_triv_pat _            = False
740

741
742
743
744
745

{- *********************************************************************
*                                                                      *
  Creating big tuples and their types for full Haskell expressions.
  They work over *Ids*, and create tuples replete with their types,
Sylvain Henry's avatar
Sylvain Henry committed
746
  which is whey they are not in GHC.Hs.Utils.
747
748
*                                                                      *
********************************************************************* -}
749

750
mkLHsPatTup :: [LPat GhcTc] -> LPat GhcTc
751
mkLHsPatTup []     = noLoc $ mkVanillaTuplePat [] Boxed
752
mkLHsPatTup [lpat] = lpat
753
mkLHsPatTup lpats  = L (getLoc (head lpats)) $
754
                     mkVanillaTuplePat lpats Boxed
755

756
mkVanillaTuplePat :: [OutPat GhcTc] -> Boxity -> Pat GhcTc
757
-- A vanilla tuple pattern simply gets its type from its sub-patterns
758
mkVanillaTuplePat pats box = TuplePat (map hsLPatType pats) pats box
759

760
-- The Big equivalents for the source tuple expressions
761
mkBigLHsVarTupId :: [Id] -> LHsExpr GhcTc
Simon Marlow's avatar
Simon Marlow committed
762
mkBigLHsVarTupId ids = mkBigLHsTupId (map nlHsVar ids)
763

764
mkBigLHsTupId :: [LHsExpr GhcTc] -> LHsExpr GhcTc
Simon Marlow's avatar
Simon Marlow committed
765
mkBigLHsTupId = mkChunkified mkLHsTupleExpr
766
767

-- The Big equivalents for the source tuple patterns
768
mkBigLHsVarPatTupId :: [Id] -> LPat GhcTc
Simon Marlow's avatar
Simon Marlow committed
769
mkBigLHsVarPatTupId bs = mkBigLHsPatTupId (map nlVarPat bs)
770

771
mkBigLHsPatTupId :: [LPat GhcTc] -> LPat GhcTc
Simon Marlow's avatar
Simon Marlow committed
772
mkBigLHsPatTupId = mkChunkified mkLHsPatTup
773

Austin Seipp's avatar
Austin Seipp committed
774
775
776
{-
************************************************************************
*                                                                      *
777
        Code for pattern-matching and other failures
Austin Seipp's avatar
Austin Seipp committed
778
779
*                                                                      *
************************************************************************
780
781
782
783

Generally, we handle pattern matching failure like this: let-bind a
fail-variable, and use that variable if the thing fails:
\begin{verbatim}
784
785
786
787
788
789
790
        let fail.33 = error "Help"
        in
        case x of
                p1 -> ...
                p2 -> fail.33
                p3 -> fail.33
                p4 -> ...
791
792
793
794
\end{verbatim}
Then
\begin{itemize}
\item
795
If the case can't fail, then there'll be no mention of @fail.33@, and the
796
797
798
799
800
801
802
803
804
805
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
806
unboxed type.  Then the type of @fail.33@ is unboxed too, and
807
808
there is every chance that someone will change the let into a case:
\begin{verbatim}
809
810
        case error "Help" of
          fail.33 -> case ....
811
812
813
\end{verbatim}

which is of course utterly wrong.  Rather than drop the condition that
814
only boxed types can be let-bound, we just turn the fail into a function
815
816
for the primitive case:
\begin{verbatim}
817
818
819
820
821
822
823
824
        let fail.33 :: Void -> Int#
            fail.33 = \_ -> error "Help"
        in
        case x of
                p1 -> ...
                p2 -> fail.33 void
                p3 -> fail.33 void
                p4 -> ...
825
826
\end{verbatim}

827
Now @fail.33@ is a function, so it can be let-bound.
lukemaurer's avatar
lukemaurer committed
828
829
830
831
832
833
834
835
836

We would *like* to use join points here; in fact, these "fail variables" are
paradigmatic join points! Sadly, this breaks pattern synonyms, which desugar as
CPS functions - i.e. they take "join points" as parameters. It's not impossible
to imagine extending our type system to allow passing join points around (very
carefully), but we certainly don't support it now.

99.99% of the time, the fail variables wind up as join points in short order
anyway, and the Void# doesn't do much harm.
Austin Seipp's avatar
Austin Seipp committed
837
-}
838

839
840
841
842
mkFailurePair :: CoreExpr       -- Result type of the whole case expression
              -> DsM (CoreBind, -- Binds the newly-created fail variable
                                -- to \ _ -> expression
                      CoreExpr) -- Fail variable applied to realWorld#
843
-- See Note [Failure thunks and CPR]
844
mkFailurePair expr
Simon Peyton Jones's avatar
Simon Peyton Jones committed
845
  = do { fail_fun_var <- newFailLocalDs (voidPrimTy `mkVisFunTy` ty)
846
847
848
849
       ; fail_fun_arg <- newSysLocalDs voidPrimTy
       ; let real_arg = setOneShotLambda fail_fun_arg
       ; return (NonRec fail_fun_var (Lam real_arg expr),
                 App (Var fail_fun_var) (Var voidPrimId)) }
850
  where
851
    ty = exprType expr
852

853
854
855
856
857
858
859
860
861
862
863
864
-- Uses '@mkFailurePair@' to bind the failure case. Infallible matches have
-- neither a failure arg or failure "hole", so nothing is let-bound, and no
-- extraneous Core is produced.
shareFailureHandler :: MatchResult -> MatchResult
shareFailureHandler = \case
  mr@(MR_Infallible _) -> mr
  MR_Fallible match_fn -> MR_Fallible $ \fail_expr -> do
    (fail_bind, shared_failure_handler) <- mkFailurePair fail_expr
    body <- match_fn shared_failure_handler
    -- Never unboxed, per the above, so always OK for `let` not `case`.
    return $ Let fail_bind body

Austin Seipp's avatar
Austin Seipp committed
865
{-
866
867
Note [Failure thunks and CPR]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lukemaurer's avatar
lukemaurer committed
868
869
870
(This note predates join points as formal entities (hence the quotation marks).
We can't use actual join points here (see above); if we did, this would also
solve the CPR problem, since join points don't get CPR'd. See Note [Don't CPR
Sylvain Henry's avatar
Sylvain Henry committed
871
join points] in GHC.Core.Opt.WorkWrap.)
lukemaurer's avatar
lukemaurer committed
872

873
874
875
876
When we make a failure point we ensure that it
does not look like a thunk. Example:

   let fail = \rw -> error "urk"
877
   in case x of
878
879
        [] -> fail realWorld#
        (y:ys) -> case ys of
880
                    [] -> fail realWorld#
881
882
883
884
885
886
                    (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
887
the tail call property.  For example, see #3403.
888
889
890
891
892
893
894


************************************************************************
*                                                                      *
              Ticks
*                                                                      *
********************************************************************* -}
895

896
897
mkOptTickBox :: [Tickish Id] -> CoreExpr -> CoreExpr
mkOptTickBox = flip (foldr Tick)
andy@galois.com's avatar
andy@galois.com committed
898
899
900

mkBinaryTickBox :: Int -> Int -> CoreExpr -> DsM CoreExpr
mkBinaryTickBox ixT ixF e = do
901
       uq <- newUnique
902
       this_mod <- getModule
903
904
905
906
907
       let bndr1 = mkSysLocal (fsLit "t1") uq boolTy
       let
           falseBox = Tick (HpcTick this_mod ixF) (Var falseDataConId)
           trueBox  = Tick (HpcTick this_mod ixT) (Var trueDataConId)
       --
908
909
910
911
       return $ Case e bndr1 boolTy
                       [ (DataAlt falseDataCon, [], falseBox)
                       , (DataAlt trueDataCon,  [], trueBox)
                       ]
912
913
914
915
916



-- *******************************************************************

917
918
919
920
921
922
923
924
925
926
927
928
929
930
{- Note [decideBangHood]
~~~~~~~~~~~~~~~~~~~~~~~~
With -XStrict we may make /outermost/ patterns more strict.
E.g.
       let (Just x) = e in ...
          ==>
       let !(Just x) = e in ...
and
       f x = e
          ==>
       f !x = e

This adjustment is done by decideBangHood,

931
  * Just before constructing an EqnInfo, in GHC.HsToCore.Match
932
933
      (matchWrapper and matchSinglePat)

934
  * When desugaring a pattern-binding in GHC.HsToCore.Binds.dsHsBind
935
936
937
938
939
940
941
942
943
944
945
946

Note that it is /not/ done recursively.  See the -XStrict
spec in the user manual.

Specifically:
   ~pat    => pat    -- when -XStrict (even if pat = ~pat')
   !pat    => !pat   -- always
   pat     => !pat   -- when -XStrict
   pat     => pat    -- otherwise
-}


947
-- | Use -XStrict to add a ! or remove a ~
948
-- See Note [decideBangHood]
949
decideBangHood :: DynFlags
950
951
               -> LPat GhcTc  -- ^ Original pattern
               -> LPat GhcTc  -- Pattern with bang if necessary
952
decideBangHood dflags lpat
953
954
955
  | not (xopt LangExt.Strict dflags)
  = lpat
  | otherwise   --  -XStrict
956
957
  = go lpat
  where
958
    go lp@(L l p)
959
      = case p of
960
           ParPat x p    -> L l (ParPat x (go p))
961
962
           LazyPat _ lp' -> lp'
           BangPat _ _   -> lp
963
           _             -> L l (BangPat noExtField lp)
Ben Gamari's avatar
Ben Gamari committed
964

965
966
967
968
969
970
971
972
isTrueLHsExpr :: LHsExpr GhcTc -> Maybe (CoreExpr -> DsM CoreExpr)

-- Returns Just {..} if we're sure that the expression is True
-- I.e.   * 'True' datacon
--        * 'otherwise' Id
--        * Trivial wappings of these
-- The arguments to Just are any HsTicks that we have found,
-- because we still want to tick then, even it they are always evaluated.
973
isTrueLHsExpr (L _ (HsVar _ (L _ v)))
974
975
  |  v `hasKey` otherwiseIdKey
     || v `hasKey` getUnique trueDataConId
976
977
                                              = Just return
        -- trueDataConId doesn't have the same unique as trueDataCon
978
isTrueLHsExpr (L _ (HsConLikeOut _ con))
979
  | con `hasKey` getUnique trueDataCon = Just return
980
isTrueLHsExpr (L _ (HsTick _ tickish e))
981
982
983
984
985
    | Just ticks <- isTrueLHsExpr e
    = Just (\x -> do wrapped <- ticks x
                     return (Tick tickish wrapped))
   -- This encodes that the result is constant True for Hpc tick purposes;
   -- which is specifically what isTrueLHsExpr is trying to find out.
986
isTrueLHsExpr (L _ (HsBinTick _ ixT _ e))
987
988
989
990
991
    | Just ticks <- isTrueLHsExpr e
    = Just (\x -> do e <- ticks x
                     this_mod <- getModule
                     return (Tick (HpcTick this_mod ixT) e))

992
993
isTrueLHsExpr (L _ (HsPar _ e))   = isTrueLHsExpr e
isTrueLHsExpr _                   = Nothing