Desugar.lhs 14.3 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

The Desugarer: turning HsSyn into Core.
7
8

\begin{code}
9
module Desugar ( deSugar, deSugarExpr ) where
10

Simon Marlow's avatar
Simon Marlow committed
11
12
13
14
15
16
17
18
import DynFlags
import StaticFlags
import HscTypes
import HsSyn
import TcRnTypes
import MkIface
import Id
import Name
19
import CoreSyn
20
import CoreSubst
Simon Marlow's avatar
Simon Marlow committed
21
import PprCore
22
import DsMonad
Simon Marlow's avatar
Simon Marlow committed
23
24
25
import DsExpr
import DsBinds
import DsForeign
26
27
import DsExpr		()	-- Forces DsExpr to be compiled; DsBinds only
				-- depends on DsExpr.hi-boot.
Simon Marlow's avatar
Simon Marlow committed
28
import Module
Simon Marlow's avatar
Simon Marlow committed
29
import RdrName
30
import NameSet
31
import NameEnv
Simon Marlow's avatar
Simon Marlow committed
32
import Rules
33
import CoreMonad	( endPass, CoreToDo(..) )
Simon Marlow's avatar
Simon Marlow committed
34
import ErrUtils
35
import Outputable
Simon Marlow's avatar
Simon Marlow committed
36
import SrcLoc
andy@galois.com's avatar
andy@galois.com committed
37
import Coverage
38
import Util
39
40
import MonadUtils
import OrdList
41
import Data.List
Simon Marlow's avatar
Simon Marlow committed
42
import Data.IORef
43
44
\end{code}

45
46
47
48
49
50
%************************************************************************
%*									*
%* 		The main function: deSugar
%*									*
%************************************************************************

51
\begin{code}
Thomas Schilling's avatar
Thomas Schilling committed
52
-- | Main entry point to the desugarer.
53
deSugar :: HscEnv -> ModLocation -> TcGblEnv -> IO (Messages, Maybe ModGuts)
54
55
56
-- Can modify PCS by faulting in more declarations

deSugar hsc_env 
andy@galois.com's avatar
andy@galois.com committed
57
        mod_loc
58
59
60
61
62
63
64
65
        tcg_env@(TcGblEnv { tcg_mod          = mod,
			    tcg_src	     = hsc_src,
		    	    tcg_type_env     = type_env,
		    	    tcg_imports      = imports,
		    	    tcg_exports      = exports,
			    tcg_keep	     = keep_var,
		    	    tcg_rdr_env      = rdr_env,
		    	    tcg_fix_env      = fix_env,
66
		    	    tcg_inst_env     = inst_env,
67
		    	    tcg_fam_inst_env = fam_inst_env,
68
69
	    	    	    tcg_warns        = warns,
	    	    	    tcg_anns         = anns,
70
			    tcg_binds        = binds,
71
		    	    tcg_imp_specs    = imp_specs,
72
73
74
75
76
77
78
                            tcg_ev_binds     = ev_binds,
                            tcg_fords        = fords,
                            tcg_rules        = rules,
                            tcg_vects        = vects,
                            tcg_insts        = insts,
                            tcg_fam_insts    = fam_insts,
                            tcg_hpc          = other_hpc_info })
79
80
81

  = do	{ let dflags = hsc_dflags hsc_env
        ; showPass dflags "Desugar"
82

83
	-- Desugar the program
84
        ; let export_set = availsToNameSet exports
Ian Lynagh's avatar
Ian Lynagh committed
85
	; let auto_scc = mkAutoScc dflags mod export_set
86
        ; let target = hscTarget dflags
87
        ; let hpcInfo = emptyHpcInfo other_hpc_info
88
89
90
91
	; (msgs, mb_res)
              <- case target of
	           HscNothing ->
                       return (emptyMessages,
92
                               Just ([], nilOL, [], [], NoStubs, hpcInfo, emptyModBreaks))
93
94
95
96
97
                   _        -> do
                     (binds_cvr,ds_hpc_info, modBreaks)
			 <- if (opt_Hpc
				  || target == HscInterpreted)
			       && (not (isHsBoot hsc_src))
98
99
                              then addCoverageTicksToBinds dflags mod mod_loc
                                                           (typeEnvTyCons type_env) binds 
100
101
                              else return (binds, hpcInfo, emptyModBreaks)
                     initDs hsc_env mod rdr_env type_env $ do
102
103
                       do { ds_ev_binds <- dsEvBinds ev_binds
                          ; core_prs <- dsTopLHsBinds auto_scc binds_cvr
104
                          ; (spec_prs, spec_rules) <- dsImpSpecs imp_specs
105
106
107
                          ; (ds_fords, foreign_prs) <- dsForeigns fords
                          ; ds_rules <- mapMaybeM dsRule rules
                          ; ds_vects <- mapM dsVect vects
108
109
110
                          ; let hpc_init
                                  | opt_Hpc   = hpcInitCode mod ds_hpc_info
                                  | otherwise = empty
111
                          ; return ( ds_ev_binds
112
                                   , foreign_prs `appOL` core_prs `appOL` spec_prs
113
                                   , spec_rules ++ ds_rules, ds_vects
114
115
                                   , ds_fords `appendStubC` hpc_init
                                   , ds_hpc_info, modBreaks) }
116

117
118
        ; case mb_res of {
           Nothing -> return (msgs, Nothing) ;
119
           Just (ds_ev_binds, all_prs, all_rules, vects0, ds_fords, ds_hpc_info, modBreaks) -> do
sof's avatar
sof committed
120

121
122
123
        {       -- Add export flags to bindings
          keep_alive <- readIORef keep_var
        ; let (rules_for_locals, rules_for_imps) 
124
                   = partition isLocalRule all_rules
125
              final_prs = addExportFlagsAndRules target
126
                              export_set keep_alive rules_for_locals (fromOL all_prs)
127
128

              final_pgm = combineEvBinds ds_ev_binds final_prs
129
130
131
132
133
        -- Notice that we put the whole lot in a big Rec, even the foreign binds
        -- When compiling PrelFloat, which defines data Float = F# Float#
        -- we want F# to be in scope in the foreign marshalling code!
        -- You might think it doesn't matter, but the simplifier brings all top-level
        -- things into the in-scope set before simplifying; so we get no unfolding for F#!
134

135
        -- Lint result if necessary, and print
136
137
138
139
        ; dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared, before opt" $
               (vcat [ pprCoreBindings final_pgm
                     , pprRules rules_for_imps ])

140
141
142
143
        ; (ds_binds, ds_rules_for_imps, ds_vects) 
            <- simpleOptPgm dflags final_pgm rules_for_imps vects0
                         -- The simpleOptPgm gets rid of type 
                         -- bindings plus any stupid dead code
sof's avatar
sof committed
144

145
        ; endPass dflags CoreDesugar ds_binds ds_rules_for_imps
146

147
        ; let used_names = mkUsedNames tcg_env
148
        ; deps <- mkDependencies tcg_env
Simon Marlow's avatar
Simon Marlow committed
149
150

        ; let mod_guts = ModGuts {	
151
152
153
154
		mg_module    	= mod,
		mg_boot	     	= isHsBoot hsc_src,
		mg_exports   	= exports,
		mg_deps	     	= deps,
Simon Marlow's avatar
Simon Marlow committed
155
156
		mg_used_names   = used_names,
		mg_dir_imps  	= imp_mods imports,
157
158
	        mg_rdr_env   	= rdr_env,
		mg_fix_env   	= fix_env,
Ian Lynagh's avatar
Ian Lynagh committed
159
		mg_warns   	= warns,
160
		mg_anns      	= anns,
161
162
163
		mg_types     	= type_env,
		mg_insts     	= insts,
		mg_fam_insts 	= fam_insts,
164
		mg_inst_env     = inst_env,
165
		mg_fam_inst_env = fam_inst_env,
166
	        mg_rules     	= ds_rules_for_imps,
167
168
169
		mg_binds     	= ds_binds,
		mg_foreign   	= ds_fords,
		mg_hpc_info  	= ds_hpc_info,
170
                mg_modBreaks    = modBreaks,
171
                mg_vect_decls   = ds_vects,
172
173
                mg_vect_info    = noVectInfo,
                mg_trust_pkg    = imp_trust_own_pkg imports
174
              }
175
        ; return (msgs, Just mod_guts)
176
	}}}
177

178
179
180
181
182
dsImpSpecs :: [LTcSpecPrag] -> DsM (OrdList (Id,CoreExpr), [CoreRule])
dsImpSpecs imp_specs
 = do { spec_prs <- mapMaybeM (dsSpec Nothing) imp_specs
      ; let (spec_binds, spec_rules) = unzip spec_prs
      ; return (concatOL spec_binds, spec_rules) }
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209

combineEvBinds :: [DsEvBind] -> [(Id,CoreExpr)] -> [CoreBind]
-- Top-level bindings can include coercion bindings, but not via superclasses
-- See Note [Top-level evidence]
combineEvBinds [] val_prs 
  = [Rec val_prs]
combineEvBinds (LetEvBind (NonRec b r) : bs) val_prs
  | isId b    = combineEvBinds bs ((b,r):val_prs)
  | otherwise = NonRec b r : combineEvBinds bs val_prs
combineEvBinds (LetEvBind (Rec prs) : bs) val_prs 
  = combineEvBinds bs (prs ++ val_prs)
combineEvBinds (CaseEvBind x _ _ : _) _
  = pprPanic "topEvBindPairs" (ppr x)
\end{code}

Note [Top-level evidence]
~~~~~~~~~~~~~~~~~~~~~~~~~
Top-level evidence bindings may be mutually recursive with the top-level value
bindings, so we must put those in a Rec.  But we can't put them *all* in a Rec
because the occurrence analyser doesn't teke account of type/coercion variables
when computing dependencies.  

So we pull out the type/coercion variables (which are in dependency order),
and Rec the rest.


\begin{code}
Ian Lynagh's avatar
Ian Lynagh committed
210
211
mkAutoScc :: DynFlags -> Module -> NameSet -> AutoScc
mkAutoScc dflags mod exports
212
213
  | not opt_SccProfilingOn 	-- No profiling
  = NoSccs		
Ian Lynagh's avatar
Ian Lynagh committed
214
215
    -- Add auto-scc on all top-level things
  | dopt Opt_AutoSccsOnAllToplevs dflags
216
217
218
219
  = AddSccs mod (\id -> not $ isDerivedOccName $ getOccName id)
    -- See #1641.  This is pretty yucky, but I can't see a better way
    -- to identify compiler-generated Ids, and at least this should
    -- catch them all.
Ian Lynagh's avatar
Ian Lynagh committed
220
221
    -- Only on exported things
  | dopt Opt_AutoSccsOnExportedToplevs dflags
222
223
224
225
  = AddSccs mod (\id -> idName id `elemNameSet` exports)
  | otherwise
  = NoSccs

226
deSugarExpr :: HscEnv
227
	    -> Module -> GlobalRdrEnv -> TypeEnv 
228
 	    -> LHsExpr Id
229
	    -> IO (Messages, Maybe CoreExpr)
230
231
-- Prints its own errors; returns Nothing if error occurred

232
233
234
deSugarExpr hsc_env this_mod rdr_env type_env tc_expr = do
    let dflags = hsc_dflags hsc_env
    showPass dflags "Desugar"
235

236
237
238
    -- Do desugaring
    (msgs, mb_core_expr) <- initDs hsc_env this_mod rdr_env type_env $
                                   dsLExpr tc_expr
239

240
241
242
    case mb_core_expr of
      Nothing   -> return (msgs, Nothing)
      Just expr -> do
243

244
245
        -- Dump output
        dumpIfSet_dyn dflags Opt_D_dump_ds "Desugared" (pprCoreExpr expr)
246

247
        return (msgs, Just expr)
248
\end{code}
249

250
251
252
253
254
255
256
257
258
259
260
261
%************************************************************************
%*									*
%* 		Add rules and export flags to binders
%*									*
%************************************************************************

\begin{code}
addExportFlagsAndRules 
    :: HscTarget -> NameSet -> NameSet -> [CoreRule]
    -> [(Id, t)] -> [(Id, t)]
addExportFlagsAndRules target exports keep_alive rules prs
  = mapFst add_one prs
262
  where
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
    add_one bndr = add_rules name (add_export name bndr)
       where
         name = idName bndr

    ---------- Rules --------
	-- See Note [Attach rules to local ids]
	-- NB: the binder might have some existing rules,
	-- arising from specialisation pragmas
    add_rules name bndr
	| Just rules <- lookupNameEnv rule_base name
	= bndr `addIdSpecialisations` rules
	| otherwise
	= bndr
    rule_base = extendRuleBaseList emptyRuleBase rules

    ---------- Export flag --------
    -- See Note [Adding export flags]
    add_export name bndr
	| dont_discard name = setIdExported bndr
282
	| otherwise	    = bndr
283

284
285
    dont_discard :: Name -> Bool
    dont_discard name = is_exported name
286
287
288
289
290
291
292
293
294
295
		     || name `elemNameSet` keep_alive

    	-- In interactive mode, we don't want to discard any top-level
    	-- entities at all (eg. do not inline them away during
    	-- simplification), and retain them all in the TypeEnv so they are
    	-- available from the command line.
	--
	-- isExternalName separates the user-defined top-level names from those
	-- introduced by the type checker.
    is_exported :: Name -> Bool
296
    is_exported | target == HscInterpreted = isExternalName
297
		| otherwise 		   = (`elemNameSet` exports)
298
299
\end{code}

sof's avatar
sof committed
300

301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
Note [Adding export flags]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Set the no-discard flag if either 
	a) the Id is exported
	b) it's mentioned in the RHS of an orphan rule
	c) it's in the keep-alive set

It means that the binding won't be discarded EVEN if the binding
ends up being trivial (v = w) -- the simplifier would usually just 
substitute w for v throughout, but we don't apply the substitution to
the rules (maybe we should?), so this substitution would make the rule
bogus.

You might wonder why exported Ids aren't already marked as such;
it's just because the type checker is rather busy already and
I didn't want to pass in yet another mapping.

Note [Attach rules to local ids]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Find the rules for locally-defined Ids; then we can attach them
to the binders in the top-level bindings

Reason
  - It makes the rules easier to look up
  - It means that transformation rules and specialisations for
    locally defined Ids are handled uniformly
  - It keeps alive things that are referred to only from a rule
    (the occurrence analyser knows about rules attached to Ids)
  - It makes sure that, when we apply a rule, the free vars
    of the RHS are more likely to be in scope
  - The imported rules are carried in the in-scope set
    which is extended on each iteration by the new wave of
    local binders; any rules which aren't on the binding will
    thereby get dropped

336
337
338
339
340
341
342
343

%************************************************************************
%*									*
%* 		Desugaring transformation rules
%*									*
%************************************************************************

\begin{code}
Simon Marlow's avatar
Simon Marlow committed
344
345
dsRule :: LRuleDecl Id -> DsM (Maybe CoreRule)
dsRule (L loc (HsRule name act vars lhs _tv_lhs rhs _fv_rhs))
346
  = putSrcSpanDs loc $ 
347
    do	{ let bndrs' = [var | RuleBndr (L _ var) <- vars]
348

349
        ; lhs' <- unsetOptM Opt_EnableRewriteRules $
350
                  unsetWOptM Opt_WarnIdentities $
351
                  dsLExpr lhs   -- Note [Desugaring RULE left hand sides]
352

353
	; rhs' <- dsLExpr rhs
354
355
356

	-- Substitute the dict bindings eagerly,
	-- and take the body apart into a (f args) form
357
358
359
	; case decomposeRuleLhs bndrs' lhs' of {
		Left msg -> do { warnDs msg; return Nothing } ;
		Right (final_bndrs, fn_id, args) -> do
360
	
361
	{ let is_local = isLocalId fn_id
362
363
364
		-- NB: isLocalId is False of implicit Ids.  This is good becuase
		-- we don't want to attach rules to the bindings of implicit Ids, 
		-- because they don't show up in the bindings until just before code gen
365
366
	      fn_name   = idName fn_id
	      final_rhs = simpleOptExpr rhs'	-- De-crap it
367
	      rule      = mkRule False {- Not auto -} is_local 
368
                                 name act fn_name final_bndrs args final_rhs
369
370
	; return (Just rule)
	} } }
371
\end{code}
372

373
374
375
376
377
378
Note [Desugaring RULE left hand sides]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For the LHS of a RULE we do *not* want to desugar
    [x]   to    build (\cn. x `c` n)
We want to leave explicit lists simply as chains
of cons's. We can achieve that slightly indirectly by
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
379
switching off EnableRewriteRules.  See DsExpr.dsExplicitList.
380
381

That keeps the desugaring of list comprehensions simple too.
382

383
384


385
386
387
Nor do we want to warn of conversion identities on the LHS;
the rule is precisly to optimise them:
  {-# RULES "fromRational/id" fromRational = id :: Rational -> Rational #-}
388
389
390
391
392
393
394
395
396
397


%************************************************************************
%*                                                                      *
%*              Desugaring vectorisation declarations
%*                                                                      *
%************************************************************************

\begin{code}
dsVect :: LVectDecl Id -> DsM CoreVect
398
dsVect (L loc (HsVect (L _ v) rhs))
399
400
  = putSrcSpanDs loc $ 
    do { rhs' <- fmapMaybeM dsLExpr rhs
401
       ; return $ Vect v rhs'
402
  	   }
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
403
dsVect (L _loc (HsNoVect (L _ v)))
404
  = return $ NoVect v
405
\end{code}