DsBinds.lhs 29.7 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

Pattern-matching bindings (HsBinds and MonoBinds)
7

8
9
10
Handles @HsBinds@; those at the top level require different handling,
in that the @Rec@/@NonRec@/etc structure is thrown away (whereas at
lower levels it is preserved with @let@/@letrec@s).
11
12

\begin{code}
Ian Lynagh's avatar
Ian Lynagh committed
13
14
15
16
17
18
19
{-# 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

20
module DsBinds ( dsTopLHsBinds, dsLHsBinds, decomposeRuleLhs, dsSpec,
21
                 dsHsWrapper, dsTcEvBinds, dsEvBinds, dsTcCoercion
22
  ) where
23

24
25
#include "HsVersions.h"

26
import {-# SOURCE #-}	DsExpr( dsLExpr )
27
28
import {-# SOURCE #-}	Match( matchWrapper )

29
import DsMonad
Simon Marlow's avatar
Simon Marlow committed
30
import DsGRHSs
31
import DsUtils
32

33
34
import HsSyn		-- lots of things
import CoreSyn		-- lots of things
35
import Literal          ( Literal(MachStr) )
36
import CoreSubst
37
import MkCore
Simon Marlow's avatar
Simon Marlow committed
38
import CoreUtils
39
import CoreArity ( etaExpand )
40
import CoreUnfold
41
import CoreFVs
42
import Digraph
43

44

batterseapower's avatar
batterseapower committed
45
import TyCon      ( isTupleTyCon, tyConDataCons_maybe )
46
import TcEvidence
47
import TcType
48
import Type
batterseapower's avatar
batterseapower committed
49
50
import Coercion hiding (substCo)
import TysWiredIn ( eqBoxDataCon, tupleCon )
Simon Marlow's avatar
Simon Marlow committed
51
import Id
52
import Class
batterseapower's avatar
batterseapower committed
53
import DataCon	( dataConWorkId )
54
import Name	( Name, localiseName )
55
import MkId	( seqId )
56
import Var
57
import VarSet
Simon Marlow's avatar
Simon Marlow committed
58
import Rules
59
import VarEnv
60
import Outputable
Simon Marlow's avatar
Simon Marlow committed
61
62
import SrcLoc
import Maybes
63
import OrdList
Simon Marlow's avatar
Simon Marlow committed
64
65
import Bag
import BasicTypes hiding ( TopLevel )
Ian Lynagh's avatar
Ian Lynagh committed
66
import DynFlags
Simon Marlow's avatar
Simon Marlow committed
67
import FastString
68
import ErrUtils( MsgDoc )
69
import Util
70
import Control.Monad( when )
71
import MonadUtils
72
73
74
75
76
77
78
79
80
\end{code}

%************************************************************************
%*									*
\subsection[dsMonoBinds]{Desugaring a @MonoBinds@}
%*									*
%************************************************************************

\begin{code}
81
82
dsTopLHsBinds :: LHsBinds Id -> DsM (OrdList (Id,CoreExpr))
dsTopLHsBinds binds = ds_lhs_binds binds
83

84
dsLHsBinds :: LHsBinds Id -> DsM [(Id,CoreExpr)]
85
dsLHsBinds binds = do { binds' <- ds_lhs_binds binds
86
                      ; return (fromOL binds') }
87
88

------------------------
89
ds_lhs_binds :: LHsBinds Id -> DsM (OrdList (Id,CoreExpr))
90

91
92
ds_lhs_binds binds = do { ds_bs <- mapBagM dsLHsBind binds
                        ; return (foldBag appOL id nilOL ds_bs) }
93

94
95
96
dsLHsBind :: LHsBind Id -> DsM (OrdList (Id,CoreExpr))
dsLHsBind (L loc bind)
  = putSrcSpanDs loc $ dsHsBind bind
97

98
dsHsBind :: HsBind Id -> DsM (OrdList (Id,CoreExpr))
99

100
dsHsBind (VarBind { var_id = var, var_rhs = expr, var_inline = inline_regardless })
101
  = do  { core_expr <- dsLExpr expr
102
103
104

	        -- Dictionary bindings are always VarBinds,
	        -- so we only need do this here
105
        ; let var' | inline_regardless = var `setIdUnfolding` mkCompulsoryUnfolding core_expr
106
	      	   | otherwise         = var
107

108
        ; return (unitOL (makeCorePair var' False 0 core_expr)) }
109

110
111
112
dsHsBind (FunBind { fun_id = L _ fun, fun_matches = matches
                  , fun_co_fn = co_fn, fun_tick = tick
                  , fun_infix = inf })
113
 = do	{ (args, body) <- matchWrapper (FunRhs (idName fun) inf) matches
114
        ; let body' = mkOptTickBox tick body
115
              rhs = dsHsWrapper co_fn (mkLams args body')
116
117
118
119
120
        ; {- pprTrace "dsHsBind" (ppr fun <+> ppr (idInlinePragma fun)) $ -}
           return (unitOL (makeCorePair fun False 0 rhs)) }

dsHsBind (PatBind { pat_lhs = pat, pat_rhs = grhss, pat_rhs_ty = ty
                  , pat_ticks = (rhs_tick, var_ticks) })
121
  = do	{ body_expr <- dsGuarded grhss ty
122
123
        ; let body' = mkOptTickBox rhs_tick body_expr
        ; sel_binds <- mkSelectorBinds var_ticks pat body'
124
125
	  -- We silently ignore inline pragmas; no makeCorePair
	  -- Not so cool, but really doesn't matter
126
    ; return (toOL sel_binds) }
sof's avatar
sof committed
127

128
	-- A common case: one exported variable
129
	-- Non-recursive bindings come through this way
130
131
	-- So do self-recursive bindings, and recursive bindings
	-- that have been chopped up with type signatures
132
133
134
dsHsBind (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dicts
                   , abs_exports = [export]
                   , abs_ev_binds = ev_binds, abs_binds = binds })
135
136
  | ABE { abe_wrap = wrap, abe_poly = global
        , abe_mono = local, abe_prags = prags } <- export
137
  = do  { bind_prs    <- ds_lhs_binds binds
138
	; let	core_bind = Rec (fromOL bind_prs)
139
                rhs       = dsHsWrapper wrap $  -- Usually the identity
140
			    mkLams tyvars $ mkLams dicts $ 
141
	                    mkCoreLets (dsTcEvBinds ev_binds) $
142
143
                            Let core_bind $
                            Var local
144
    
145
	; (spec_binds, rules) <- dsSpecs rhs prags
146
147

	; let   global'   = addIdSpecialisations global rules
148
149
		main_bind = makeCorePair global' (isDefaultMethod prags)
                                         (dictArity dicts) rhs 
150
    
151
	; return (main_bind `consOL` spec_binds) }
sof's avatar
sof committed
152

153
154
155
156
157
dsHsBind (AbsBinds { abs_tvs = tyvars, abs_ev_vars = dicts
                   , abs_exports = exports, abs_ev_binds = ev_binds
                   , abs_binds = binds })
  = do  { bind_prs    <- ds_lhs_binds binds
        ; let core_bind = Rec (fromOL bind_prs)
158
	      	-- Monomorphic recursion possible, hence Rec
159

160
161
	      tup_expr     = mkBigCoreVarTup locals
	      tup_ty	   = exprType tup_expr
162
	      poly_tup_rhs = mkLams tyvars $ mkLams dicts $
163
	      		     mkCoreLets (dsTcEvBinds ev_binds) $
164
165
			     Let core_bind $
	 	     	     tup_expr
166
	      locals       = map abe_mono exports
167

168
	; poly_tup_id <- newSysLocalDs (exprType poly_tup_rhs)
169

170
171
	; let mk_bind (ABE { abe_wrap = wrap, abe_poly = global
                           , abe_mono = local, abe_prags = spec_prags })
172
173
174
	        = do { tup_id  <- newSysLocalDs tup_ty
	             ; let rhs = dsHsWrapper wrap $ 
                                 mkLams tyvars $ mkLams dicts $
175
176
177
178
	      	     		 mkTupleSelector locals local tup_id $
			         mkVarApps (Var poly_tup_id) (tyvars ++ dicts)
                           rhs_for_spec = Let (NonRec poly_tup_id poly_tup_rhs) rhs
		     ; (spec_binds, rules) <- dsSpecs rhs_for_spec spec_prags
179
		     ; let global' = addIdSpecialisations global rules
180
		     ; return ((global', rhs) `consOL` spec_binds) }
181

182
        ; export_binds_s <- mapM mk_bind exports
183

184
185
186
	; return ((poly_tup_id, poly_tup_rhs) `consOL` 
		    concatOL export_binds_s) }

187
------------------------
188
189
190
191
192
makeCorePair :: Id -> Bool -> Arity -> CoreExpr -> (Id, CoreExpr)
makeCorePair gbl_id is_default_method dict_arity rhs
  | is_default_method		      -- Default methods are *always* inlined
  = (gbl_id `setIdUnfolding` mkCompulsoryUnfolding rhs, rhs)

193
194
195
196
197
198
  | otherwise
  = case inlinePragmaSpec inline_prag of
      	  EmptyInlineSpec -> (gbl_id, rhs)
      	  NoInline        -> (gbl_id, rhs)
      	  Inlinable       -> (gbl_id `setIdUnfolding` inlinable_unf, rhs)
          Inline          -> inline_pair
199

200
201
202
203
204
  where
    inline_prag   = idInlinePragma gbl_id
    inlinable_unf = mkInlinableUnfolding rhs
    inline_pair
       | Just arity <- inlinePragmaSat inline_prag
205
206
      	-- Add an Unfolding for an INLINE (but not for NOINLINE)
	-- And eta-expand the RHS; see Note [Eta-expanding INLINE things]
207
       , let real_arity = dict_arity + arity
208
        -- NB: The arity in the InlineRule takes account of the dictionaries
209
210
211
212
213
214
       = ( gbl_id `setIdUnfolding` mkInlineUnfolding (Just real_arity) rhs
         , etaExpand real_arity rhs)

       | otherwise
       = pprTrace "makeCorePair: arity missing" (ppr gbl_id) $
         (gbl_id `setIdUnfolding` mkInlineUnfolding Nothing rhs, rhs)
215
216
217
218
219


dictArity :: [Var] -> Arity
-- Don't count coercion variables in arity
dictArity dicts = count isId dicts
220
221
\end{code}

222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
Note [Rules and inlining]
~~~~~~~~~~~~~~~~~~~~~~~~~
Common special case: no type or dictionary abstraction
This is a bit less trivial than you might suppose
The naive way woudl be to desguar to something like
	f_lcl = ...f_lcl...	-- The "binds" from AbsBinds
	M.f = f_lcl		-- Generated from "exports"
But we don't want that, because if M.f isn't exported,
it'll be inlined unconditionally at every call site (its rhs is 
trivial).  That would be ok unless it has RULES, which would 
thereby be completely lost.  Bad, bad, bad.

Instead we want to generate
	M.f = ...f_lcl...
	f_lcl = M.f
Now all is cool. The RULES are attached to M.f (by SimplCore), 
and f_lcl is rapidly inlined away.

This does not happen in the same way to polymorphic binds,
because they desugar to
	M.f = /\a. let f_lcl = ...f_lcl... in f_lcl
Although I'm a bit worried about whether full laziness might
244
float the f_lcl binding out and then inline M.f at its call site
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304

Note [Specialising in no-dict case]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Even if there are no tyvars or dicts, we may have specialisation pragmas.
Class methods can generate
      AbsBinds [] [] [( ... spec-prag]
         { AbsBinds [tvs] [dicts] ...blah }
So the overloading is in the nested AbsBinds. A good example is in GHC.Float:

  class  (Real a, Fractional a) => RealFrac a  where
    round :: (Integral b) => a -> b

  instance  RealFrac Float  where
    {-# SPECIALIZE round :: Float -> Int #-}

The top-level AbsBinds for $cround has no tyvars or dicts (because the 
instance does not).  But the method is locally overloaded!

Note [Abstracting over tyvars only]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When abstracting over type variable only (not dictionaries), we don't really need to
built a tuple and select from it, as we do in the general case. Instead we can take

	AbsBinds [a,b] [ ([a,b], fg, fl, _),
		         ([b],   gg, gl, _) ]
		{ fl = e1
		  gl = e2
		   h = e3 }

and desugar it to

	fg = /\ab. let B in e1
	gg = /\b. let a = () in let B in S(e2)
	h  = /\ab. let B in e3

where B is the *non-recursive* binding
	fl = fg a b
	gl = gg b
	h  = h a b    -- See (b); note shadowing!

Notice (a) g has a different number of type variables to f, so we must
	     use the mkArbitraryType thing to fill in the gaps.  
	     We use a type-let to do that.

	 (b) The local variable h isn't in the exports, and rather than
	     clone a fresh copy we simply replace h by (h a b), where
	     the two h's have different types!  Shadowing happens here,
	     which looks confusing but works fine.

	 (c) The result is *still* quadratic-sized if there are a lot of
	     small bindings.  So if there are more than some small
	     number (10), we filter the binding set B by the free
	     variables of the particular RHS.  Tiresome.

Why got to this trouble?  It's a common case, and it removes the
quadratic-sized tuple desugaring.  Less clutter, hopefullly faster
compilation, especially in a case where there are a *lot* of
bindings.


305
306
307
308
309
310
311
312
313
314
315
316
317
Note [Eta-expanding INLINE things]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
   foo :: Eq a => a -> a
   {-# INLINE foo #-}
   foo x = ...

If (foo d) ever gets floated out as a common sub-expression (which can
happen as a result of method sharing), there's a danger that we never 
get to do the inlining, which is a Terribly Bad thing given that the
user said "inline"!

To avoid this we pre-emptively eta-expand the definition, so that foo
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
318
319
320
has the arity with which it is declared in the source code.  In this
example it has arity 2 (one for the Eq and one for x). Doing this 
should mean that (foo d) is a PAP and we don't share it.
321
322
323

Note [Nested arities]
~~~~~~~~~~~~~~~~~~~~~
324
325
326
327
328
329
330
331
332
333
334
335
336
337
For reasons that are not entirely clear, method bindings come out looking like
this:

  AbsBinds [] [] [$cfromT <= [] fromT]
    $cfromT [InlPrag=INLINE] :: T Bool -> Bool
    { AbsBinds [] [] [fromT <= [] fromT_1]
        fromT :: T Bool -> Bool
        { fromT_1 ((TBool b)) = not b } } }

Note the nested AbsBind.  The arity for the InlineRule on $cfromT should be
gotten from the binding for fromT_1.

It might be better to have just one level of AbsBinds, but that requires more
thought!
338

339
340
341
342
343
Note [Implementing SPECIALISE pragmas]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Example:
	f :: (Eq a, Ix b) => a -> b -> Bool
	{-# SPECIALISE f :: (Ix p, Ix q) => Int -> (p,q) -> Bool #-}
344
        f = <poly_rhs>
345
346
347
348
349
350
351
352
353

From this the typechecker generates

    AbsBinds [ab] [d1,d2] [([ab], f, f_mono, prags)] binds

    SpecPrag (wrap_fn :: forall a b. (Eq a, Ix b) => XXX
                      -> forall p q. (Ix p, Ix q) => XXX[ Int/a, (p,q)/b ])

Note that wrap_fn can transform *any* function with the right type prefix 
354
355
    forall ab. (Eq a, Ix b) => XXX
regardless of XXX.  It's sort of polymorphic in XXX.  This is
356
357
358
359
360
361
362
363
useful: we use the same wrapper to transform each of the class ops, as
well as the dict.

From these we generate:

    Rule: 	forall p, q, (dp:Ix p), (dq:Ix q). 
                    f Int (p,q) dInt ($dfInPair dp dq) = f_spec p q dp dq

364
    Spec bind:	f_spec = wrap_fn <poly_rhs>
365
366
367
368
369
370
371

Note that 

  * The LHS of the rule may mention dictionary *expressions* (eg
    $dfIxPair dp dq), and that is essential because the dp, dq are
    needed on the RHS.

372
373
  * The RHS of f_spec, <poly_rhs> has a *copy* of 'binds', so that it 
    can fully specialise it.
374

375
376
\begin{code}
------------------------
377
dsSpecs :: CoreExpr     -- Its rhs
378
        -> TcSpecPrags
379
        -> DsM ( OrdList (Id,CoreExpr) 	-- Binding for specialised Ids
380
	       , [CoreRule] )		-- Rules for the Global Ids
381
-- See Note [Implementing SPECIALISE pragmas]
382
383
384
385
386
387
388
389
390
391
392
393
dsSpecs _ IsDefaultMethod = return (nilOL, [])
dsSpecs poly_rhs (SpecPrags sps)
  = do { pairs <- mapMaybeM (dsSpec (Just poly_rhs)) sps
       ; let (spec_binds_s, rules) = unzip pairs
       ; return (concatOL spec_binds_s, rules) }

dsSpec :: Maybe CoreExpr  	-- Just rhs => RULE is for a local binding
       	  			-- Nothing => RULE is for an imported Id
				-- 	      rhs is in the Id's unfolding
       -> Located TcSpecPrag
       -> DsM (Maybe (OrdList (Id,CoreExpr), CoreRule))
dsSpec mb_poly_rhs (L loc (SpecPrag poly_id spec_co spec_inl))
394
395
396
397
398
399
400
401
  | isJust (isClassOpId_maybe poly_id)
  = putSrcSpanDs loc $ 
    do { warnDs (ptext (sLit "Ignoring useless SPECIALISE pragma for class method selector") 
                 <+> quotes (ppr poly_id))
       ; return Nothing  }  -- There is no point in trying to specialise a class op
       	 		    -- Moreover, classops don't (currently) have an inl_sat arity set
			    -- (it would be Just 0) and that in turn makes makeCorePair bleat

402
403
404
405
406
407
408
  | no_act_spec && isNeverActive rule_act 
  = putSrcSpanDs loc $ 
    do { warnDs (ptext (sLit "Ignoring useless SPECIALISE pragma for NOINLINE function:")
                 <+> quotes (ppr poly_id))
       ; return Nothing  }  -- Function is NOINLINE, and the specialiation inherits that
       	 		    -- See Note [Activation pragmas for SPECIALISE]

409
  | otherwise
410
411
412
  = putSrcSpanDs loc $ 
    do { let poly_name = idName poly_id
       ; spec_name <- newLocalName poly_name
413
       ; let (bndrs, ds_lhs) = collectBinders (dsHsWrapper spec_co (Var poly_id))
414
             spec_ty = mkPiTypes bndrs (exprType ds_lhs)
415
416
417
       ; case decomposeRuleLhs bndrs ds_lhs of {
           Left msg -> do { warnDs msg; return Nothing } ;
           Right (final_bndrs, _fn, args) -> do
418

419
       { (spec_unf, unf_pairs) <- specUnfolding spec_co spec_ty (realIdUnfolding poly_id)
420
421
422
423
424
425

       ; let spec_id  = mkLocalId spec_name spec_ty 
         	            `setInlinePragma` inl_prag
         	 	    `setIdUnfolding`  spec_unf
             rule =  mkRule False {- Not auto -} is_local_id
                        (mkFastString ("SPEC " ++ showSDoc (ppr poly_name)))
426
       			rule_act poly_name
427
       		        final_bndrs args
428
429
       			(mkVarApps (Var spec_id) bndrs)

430
             spec_rhs  = dsHsWrapper spec_co poly_rhs
431
432
             spec_pair = makeCorePair spec_id False (dictArity bndrs) spec_rhs

Ian Lynagh's avatar
Ian Lynagh committed
433
434
435
       ; dflags <- getDynFlags
       ; when (isInlinePragma id_inl && wopt Opt_WarnPointlessPragmas dflags)
              (warnDs (specOnInline poly_name))
436
437
438
439
440
       ; return (Just (spec_pair `consOL` unf_pairs, rule))
       } } }
  where
    is_local_id = isJust mb_poly_rhs
    poly_rhs | Just rhs <-  mb_poly_rhs
441
442
443
444
445
446
             = rhs  	    -- Local Id; this is its rhs
             | Just unfolding <- maybeUnfoldingTemplate (realIdUnfolding poly_id)
             = unfolding    -- Imported Id; this is its unfolding
	       		    -- Use realIdUnfolding so we get the unfolding 
			    -- even when it is a loop breaker. 
			    -- We want to specialise recursive functions!
447
             | otherwise = pprPanic "dsImpSpecs" (ppr poly_id)
448
	                    -- The type checker has checked that it *has* an unfolding
449

450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
    id_inl = idInlinePragma poly_id

    -- See Note [Activation pragmas for SPECIALISE]
    inl_prag | not (isDefaultInlinePragma spec_inl)    = spec_inl
             | not is_local_id  -- See Note [Specialising imported functions]
             	    		 -- in OccurAnal
             , isStrongLoopBreaker (idOccInfo poly_id) = neverInlinePragma
             | otherwise                               = id_inl
     -- Get the INLINE pragma from SPECIALISE declaration, or,
     -- failing that, from the original Id

    spec_prag_act = inlinePragmaActivation spec_inl

    -- See Note [Activation pragmas for SPECIALISE]
    -- no_act_spec is True if the user didn't write an explicit
    -- phase specification in the SPECIALISE pragma
    no_act_spec = case inlinePragmaSpec spec_inl of
                    NoInline -> isNeverActive  spec_prag_act
                    _        -> isAlwaysActive spec_prag_act
    rule_act | no_act_spec = inlinePragmaActivation id_inl   -- Inherit
             | otherwise   = spec_prag_act                   -- Specified by user


473
specUnfolding :: HsWrapper -> Type 
474
              -> Unfolding -> DsM (Unfolding, OrdList (Id,CoreExpr))
475
476
477
{-   [Dec 10: TEMPORARILY commented out, until we can straighten out how to
              generate unfoldings for specialised DFuns

478
specUnfolding wrap_fn spec_ty (DFunUnfolding _ _ ops)
479
480
  = do { let spec_rhss = map wrap_fn ops
       ; spec_ids <- mapM (mkSysLocalM (fsLit "spec") . exprType) spec_rhss
481
       ; return (mkDFunUnfolding spec_ty (map Var spec_ids), toOL (spec_ids `zip` spec_rhss)) }
482
-}
483
specUnfolding _ _ _
484
  = return (noUnfolding, nilOL)
485
486
487
488

specOnInline :: Name -> MsgDoc
specOnInline f = ptext (sLit "SPECIALISE pragma on INLINE function probably won't fire:") 
                 <+> quotes (ppr f)
489
490
\end{code}

491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532

Note [Activation pragmas for SPECIALISE]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
From a user SPECIALISE pragma for f, we generate
  a) A top-level binding    spec_fn = rhs
  b) A RULE                 f dOrd = spec_fn

We need two pragma-like things:

* spec_fn's inline pragma: inherited from f's inline pragma (ignoring 
                           activation on SPEC), unless overriden by SPEC INLINE

* Activation of RULE: from SPECIALISE pragma (if activation given)
                      otherwise from f's inline pragma

This is not obvious (see Trac #5237)!

Examples      Rule activation   Inline prag on spec'd fn
---------------------------------------------------------------------
SPEC [n] f :: ty            [n]   Always, or NOINLINE [n]
                                  copy f's prag

NOINLINE f
SPEC [n] f :: ty            [n]   NOINLINE
                                  copy f's prag

NOINLINE [k] f
SPEC [n] f :: ty            [n]   NOINLINE [k]
                                  copy f's prag

INLINE [k] f
SPEC [n] f :: ty            [n]   INLINE [k] 
                                  copy f's prag

SPEC INLINE [n] f :: ty     [n]   INLINE [n]
                                  (ignore INLINE prag on f,
                                  same activation for rule and spec'd fn)

NOINLINE [k] f
SPEC f :: ty                [n]   INLINE [k]


533
534
535
536
537
538
539
%************************************************************************
%*									*
\subsection{Adding inline pragmas}
%*									*
%************************************************************************

\begin{code}
540
decomposeRuleLhs :: [Var] -> CoreExpr -> Either SDoc ([Var], Id, [CoreExpr])
541
-- Take apart the LHS of a RULE.  It's supposed to look like
542
543
544
--     /\a. f a Int dOrdInt
-- or  /\a.\d:Ord a. let { dl::Ord [a] = dOrdList a d } in f [a] dl
-- That is, the RULE binders are lambda-bound
545
-- Returns Nothing if the LHS isn't of the expected shape
546
decomposeRuleLhs bndrs lhs 
547
  =  -- Note [Simplifying the left-hand side of a RULE]
548
549
    case collectArgs opt_lhs of
        (Var fn, args) -> check_bndrs fn args
Simon Marlow's avatar
Simon Marlow committed
550

551
552
        (Case scrut bndr ty [(DEFAULT, _, body)], args)
	        | isDeadBinder bndr	-- Note [Matching seqId]
553
		-> check_bndrs seqId (args' ++ args)
554
555
556
		where
		   args' = [Type (idType bndr), Type ty, scrut, body]
	   
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
	_other -> Left bad_shape_msg
 where
   opt_lhs = simpleOptExpr lhs

   check_bndrs fn args
     | null (dead_bndrs) = Right (extra_dict_bndrs ++ bndrs, fn, args)
     | otherwise         = Left (vcat (map dead_msg dead_bndrs))
     where
       arg_fvs = exprsFreeVars args

            -- Check for dead binders: Note [Unused spec binders]
       dead_bndrs = filterOut (`elemVarSet` arg_fvs) bndrs

            -- Add extra dict binders: Note [Constant rule dicts]
       extra_dict_bndrs = [ mkLocalId (localiseName (idName d)) (idType d)
                          | d <- varSetElems (arg_fvs `delVarSetList` bndrs)
         	          , isDictId d]


   bad_shape_msg = hang (ptext (sLit "RULE left-hand side too complicated to desugar"))
                      2 (ppr opt_lhs)
578
579
   dead_msg bndr = hang (sep [ ptext (sLit "Forall'd") <+> pp_bndr bndr
			     , ptext (sLit "is not bound in RULE lhs")])
580
581
                      2 (ppr opt_lhs)
   pp_bndr bndr
582
583
584
    | isTyVar bndr                      = ptext (sLit "type variable") <+> quotes (ppr bndr)
    | Just pred <- evVarPred_maybe bndr = ptext (sLit "constraint") <+> quotes (ppr pred)
    | otherwise                         = ptext (sLit "variable") <+> quotes (ppr bndr)
585
586
\end{code}

587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
Note [Simplifying the left-hand side of a RULE]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
simpleOptExpr occurrence-analyses and simplifies the lhs
and thereby
(a) sorts dict bindings into NonRecs and inlines them
(b) substitute trivial lets so that they don't get in the way
    Note that we substitute the function too; we might 
    have this as a LHS:  let f71 = M.f Int in f71
(c) does eta reduction

For (c) consider the fold/build rule, which without simplification
looked like:
	fold k z (build (/\a. g a))  ==>  ...
This doesn't match unless you do eta reduction on the build argument.
Similarly for a LHS like
	augment g (build h) 
we do not want to get
	augment (\a. g a) (build h)
otherwise we don't match when given an argument like
	augment (\a. h a a) (build h)

NB: tcSimplifyRuleLhs is very careful not to generate complicated
    dictionary expressions that we might have to match

611
Note [Matching seqId]
612
613
614
615
616
~~~~~~~~~~~~~~~~~~~
The desugarer turns (seq e r) into (case e of _ -> r), via a special-case hack
and this code turns it back into an application of seq!  
See Note [Rules for seq] in MkId for the details.

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
Note [Unused spec binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
	f :: a -> a
	{-# SPECIALISE f :: Eq a => a -> a #-}
It's true that this *is* a more specialised type, but the rule
we get is something like this:
	f_spec d = f
	RULE: f = f_spec d
Note that the rule is bogus, becuase it mentions a 'd' that is
not bound on the LHS!  But it's a silly specialisation anyway, becuase
the constraint is unused.  We could bind 'd' to (error "unused")
but it seems better to reject the program because it's almost certainly
a mistake.  That's what the isDeadBinder call detects.

Note [Constant rule dicts]
~~~~~~~~~~~~~~~~~~~~~~~
When the LHS of a specialisation rule, (/\as\ds. f es) has a free dict, 
which is presumably in scope at the function definition site, we can quantify 
over it too.  *Any* dict with that type will do.

So for example when you have
	f :: Eq a => a -> a
	f = <rhs>
	{-# SPECIALISE f :: Int -> Int #-}

Then we get the SpecPrag
	SpecPrag (f Int dInt) 

And from that we want the rule
	
	RULE forall dInt. f Int dInt = f_spec
	f_spec = let f = <rhs> in f Int dInt

But be careful!  That dInt might be GHC.Base.$fOrdInt, which is an External
Name, and you can't bind them in a lambda or forall without getting things
confused.   Likewise it might have an InlineRule or something, which would be
utterly bogus. So we really make a fresh Id, with the same unique and type
as the old one, but with an Internal name and no IdInfo.

657

658
659
%************************************************************************
%*									*
660
		Desugaring evidence
661
662
663
664
665
%*									*
%************************************************************************


\begin{code}
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
dsHsWrapper :: HsWrapper -> CoreExpr -> CoreExpr
dsHsWrapper WpHole 	      e = e
dsHsWrapper (WpTyApp ty)      e = App e (Type ty)
dsHsWrapper (WpLet ev_binds)  e = mkCoreLets (dsTcEvBinds ev_binds) e
dsHsWrapper (WpCompose c1 c2) e = dsHsWrapper c1 (dsHsWrapper c2 e) 
dsHsWrapper (WpCast co)       e = dsTcCoercion co (mkCast e) 
dsHsWrapper (WpEvLam ev)      e = Lam ev e 
dsHsWrapper (WpTyLam tv)      e = Lam tv e 
dsHsWrapper (WpEvApp evtrm)   e = App e (dsEvTerm evtrm)

--------------------------------------
dsTcEvBinds :: TcEvBinds -> [CoreBind]
dsTcEvBinds (TcEvBinds {}) = panic "dsEvBinds"	-- Zonker has got rid of this
dsTcEvBinds (EvBinds bs)   = dsEvBinds bs

dsEvBinds :: Bag EvBind -> [CoreBind]
dsEvBinds bs = map ds_scc (sccEvBinds bs)
  where
    ds_scc (AcyclicSCC (EvBind v r)) = NonRec v (dsEvTerm r)
    ds_scc (CyclicSCC bs)            = Rec (map ds_pair bs)

    ds_pair (EvBind v r) = (v, dsEvTerm r)

sccEvBinds :: Bag EvBind -> [SCC EvBind]
sccEvBinds bs = stronglyConnCompFromEdgedVertices edges
  where
    edges :: [(EvBind, EvVar, [EvVar])]
    edges = foldrBag ((:) . mk_node) [] bs 

    mk_node :: EvBind -> (EvBind, EvVar, [EvVar])
    mk_node b@(EvBind var term) = (b, var, evVarsOfTerm term)


---------------------------------------
dsEvTerm :: EvTerm -> CoreExpr
dsEvTerm (EvId v) = Var v

dsEvTerm (EvCast v co) 
  = dsTcCoercion co $ mkCast (Var v) -- 'v' is always a lifted evidence variable so it is
705
706
707
                                     -- unnecessary to call varToCoreExpr v here.
dsEvTerm (EvKindCast v co)
  = dsTcCoercion co $ (\_ -> Var v)
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726

dsEvTerm (EvDFunApp df tys vars) = Var df `mkTyApps` tys `mkVarApps` vars
dsEvTerm (EvCoercion co)         = dsTcCoercion co mkEqBox
dsEvTerm (EvTupleSel v n)
   = ASSERT( isTupleTyCon tc )
     Case (Var v) (mkWildValBinder (varType v)) (tys !! n) [(DataAlt dc, xs, Var v')]
  where
    (tc, tys) = splitTyConApp (evVarPred v)
    Just [dc] = tyConDataCons_maybe tc
    v' = v `setVarType` ty_want
    xs = map mkWildValBinder tys_before ++ v' : map mkWildValBinder tys_after
    (tys_before, ty_want:tys_after) = splitAt n tys
dsEvTerm (EvTupleMk vs) = Var (dataConWorkId dc) `mkTyApps` tys `mkVarApps` vs
  where dc = tupleCon ConstraintTuple (length vs)
        tys = map varType vs
dsEvTerm (EvSuperClass d n)
  = Var sc_sel_id `mkTyApps` tys `App` Var d
  where
    sc_sel_id  = classSCSelId cls n	-- Zero-indexed
727
728
729
730
    (cls, tys) = getClassPredTys (evVarPred d)   
dsEvTerm (EvDelayedError ty msg) = Var errorId `mkTyApps` [ty] `mkApps` [litMsg]
  where errorId = rUNTIME_ERROR_ID
        litMsg  = Lit (MachStr msg)
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798

---------------------------------------
dsTcCoercion :: TcCoercion -> (Coercion -> CoreExpr) -> CoreExpr
-- This is the crucial function that moves 
-- from LCoercions to Coercions; see Note [TcCoercions] in Coercion
-- e.g.  dsTcCoercion (trans g1 g2) k
--       = case g1 of EqBox g1# ->
--         case g2 of EqBox g2# ->
--         k (trans g1# g2#)
dsTcCoercion co thing_inside
  = foldr wrap_in_case result_expr eqvs_covs
  where
    result_expr = thing_inside (ds_tc_coercion subst co)
    result_ty   = exprType result_expr

    -- We use the same uniques for the EqVars and the CoVars, and just change
    -- the type. So the CoVars shadow the EqVars

    eqvs_covs :: [(EqVar,CoVar)]
    eqvs_covs = [(eqv, eqv `setIdType` mkCoercionType ty1 ty2)
                | eqv <- varSetElems (coVarsOfTcCo co)
                , let (ty1, ty2) = getEqPredTys (evVarPred eqv)]

    subst = mkCvSubst emptyInScopeSet [(eqv, mkCoVarCo cov) | (eqv, cov) <- eqvs_covs]

    wrap_in_case (eqv, cov) body 
      = Case (Var eqv) eqv result_ty [(DataAlt eqBoxDataCon, [cov], body)]

ds_tc_coercion :: CvSubst -> TcCoercion -> Coercion
-- If the incoming TcCoercion if of type (a ~ b), 
--                 the result is of type (a ~# b)
-- The VarEnv maps EqVars of type (a ~ b) to Coercions of type (a ~# b)
-- No need for InScope set etc because the 
ds_tc_coercion subst tc_co
  = go tc_co
  where
    go (TcRefl ty)            = Refl (Coercion.substTy subst ty)
    go (TcTyConAppCo tc cos)  = mkTyConAppCo tc (map go cos)
    go (TcAppCo co1 co2)      = mkAppCo (go co1) (go co2)
    go (TcForAllCo tv co)     = mkForAllCo tv' (ds_tc_coercion subst' co)
                              where
                                (subst', tv') = Coercion.substTyVarBndr subst tv
    go (TcAxiomInstCo ax tys) = mkAxInstCo ax (map (Coercion.substTy subst) tys)
    go (TcSymCo co)           = mkSymCo (go co)
    go (TcTransCo co1 co2)    = mkTransCo (go co1) (go co2)
    go (TcNthCo n co)         = mkNthCo n (go co)
    go (TcInstCo co ty)       = mkInstCo (go co) ty
    go (TcLetCo bs co)        = ds_tc_coercion (ds_co_binds bs) co
    go (TcCoVarCo v)          = ds_ev_id subst v

    ds_co_binds :: TcEvBinds -> CvSubst
    ds_co_binds (EvBinds bs)      = foldl ds_scc subst (sccEvBinds bs)
    ds_co_binds eb@(TcEvBinds {}) = pprPanic "ds_co_binds" (ppr eb)

    ds_scc :: CvSubst -> SCC EvBind -> CvSubst
    ds_scc subst (AcyclicSCC (EvBind v ev_term))
      = extendCvSubstAndInScope subst v (ds_ev_term subst ev_term)
    ds_scc _ (CyclicSCC other) = pprPanic "ds_scc:cyclic" (ppr other $$ ppr tc_co)

    ds_ev_term :: CvSubst -> EvTerm -> Coercion
    ds_ev_term subst (EvCoercion tc_co) = ds_tc_coercion subst tc_co
    ds_ev_term subst (EvId v)           = ds_ev_id subst v
    ds_ev_term _ other = pprPanic "ds_ev_term" (ppr other $$ ppr tc_co)

    ds_ev_id :: CvSubst -> EqVar -> Coercion
    ds_ev_id subst v
     | Just co <- Coercion.lookupCoVar subst v = co
     | otherwise  = pprPanic "ds_tc_coercion" (ppr v $$ ppr tc_co)
799
\end{code}