Make the matcher and wrapper Ids in PatSyn into LocalIds, not GlobalIds
[ghc.git] / compiler / basicTypes / Id.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 \section[Id]{@Ids@: Value and constructor identifiers}
6
7 \begin{code}
8 {-# LANGUAGE CPP #-}
9
10 -- |
11 -- #name_types#
12 -- GHC uses several kinds of name internally:
13 --
14 -- * 'OccName.OccName': see "OccName#name_types"
15 --
16 -- * 'RdrName.RdrName': see "RdrName#name_types"
17 --
18 -- * 'Name.Name': see "Name#name_types"
19 --
20 -- * 'Id.Id' represents names that not only have a 'Name.Name' but also a 'TypeRep.Type' and some additional
21 --   details (a 'IdInfo.IdInfo' and one of 'Var.LocalIdDetails' or 'IdInfo.GlobalIdDetails') that
22 --   are added, modified and inspected by various compiler passes. These 'Var.Var' names may either
23 --   be global or local, see "Var#globalvslocal"
24 --
25 -- * 'Var.Var': see "Var#name_types"
26
27 module Id (
28         -- * The main types
29         Var, Id, isId,
30
31         -- ** Simple construction
32         mkGlobalId, mkVanillaGlobal, mkVanillaGlobalWithInfo,
33         mkLocalId, mkLocalIdWithInfo, mkExportedLocalId,
34         mkSysLocal, mkSysLocalM, mkUserLocal, mkUserLocalM,
35         mkDerivedLocalM,
36         mkTemplateLocals, mkTemplateLocalsNum, mkTemplateLocal,
37         mkWorkerId, mkWiredInIdName,
38
39         -- ** Taking an Id apart
40         idName, idType, idUnique, idInfo, idDetails, idRepArity,
41         recordSelectorFieldLabel,
42
43         -- ** Modifying an Id
44         setIdName, setIdUnique, Id.setIdType, 
45         setIdExported, setIdNotExported, 
46         globaliseId, localiseId, 
47         setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
48         zapLamIdInfo, zapDemandIdInfo, zapFragileIdInfo, transferPolyIdInfo,
49         zapIdStrictness,
50
51         -- ** Predicates on Ids
52         isImplicitId, isDeadBinder, 
53         isStrictId,
54         isExportedId, isLocalId, isGlobalId,
55         isRecordSelector, isNaughtyRecordSelector,
56         isClassOpId_maybe, isDFunId,
57         isPrimOpId, isPrimOpId_maybe,
58         isFCallId, isFCallId_maybe,
59         isDataConWorkId, isDataConWorkId_maybe, isDataConId_maybe, idDataCon,
60         isConLikeId, isBottomingId, idIsFrom,
61         hasNoBinding,
62
63         -- ** Evidence variables
64         DictId, isDictId, dfunNSilent, isEvVar,
65
66         -- ** Inline pragma stuff
67         idInlinePragma, setInlinePragma, modifyInlinePragma,
68         idInlineActivation, setInlineActivation, idRuleMatchInfo,
69
70         -- ** One-shot lambdas
71         isOneShotBndr, isOneShotLambda, isProbablyOneShotLambda,
72         setOneShotLambda, clearOneShotLambda, 
73         updOneShotInfo, setIdOneShotInfo,
74         isStateHackType, stateHackOneShot, typeOneShot,
75
76         -- ** Reading 'IdInfo' fields
77         idArity,
78         idCallArity,
79         idUnfolding, realIdUnfolding,
80         idSpecialisation, idCoreRules, idHasRules,
81         idCafInfo,
82         idOneShotInfo,
83         idOccInfo,
84
85         -- ** Writing 'IdInfo' fields
86         setIdUnfoldingLazily,
87         setIdUnfolding,
88         setIdArity,
89         setIdCallArity,
90
91         setIdSpecialisation,
92         setIdCafInfo,
93         setIdOccInfo, zapIdOccInfo,
94
95         setIdDemandInfo, 
96         setIdStrictness, 
97
98         idDemandInfo, 
99         idStrictness,
100
101     ) where
102
103 #include "HsVersions.h"
104
105 import CoreSyn ( CoreRule, Unfolding( NoUnfolding ) )
106
107 import IdInfo
108 import BasicTypes
109
110 -- Imported and re-exported
111 import Var( Id, DictId,
112             idInfo, idDetails, globaliseId, varType,
113             isId, isLocalId, isGlobalId, isExportedId )
114 import qualified Var
115
116 import TyCon
117 import Type
118 import TysPrim
119 import DataCon
120 import Demand
121 import Name
122 import Module
123 import Class
124 import {-# SOURCE #-} PrimOp (PrimOp)
125 import ForeignCall
126 import Maybes
127 import SrcLoc
128 import Outputable
129 import Unique
130 import UniqSupply
131 import FastString
132 import Util
133 import StaticFlags
134
135 -- infixl so you can say (id `set` a `set` b)
136 infixl  1 `setIdUnfoldingLazily`,
137           `setIdUnfolding`,
138           `setIdArity`,
139           `setIdCallArity`,
140           `setIdOccInfo`,
141           `setIdOneShotInfo`,
142
143           `setIdSpecialisation`,
144           `setInlinePragma`,
145           `setInlineActivation`,
146           `idCafInfo`,
147
148           `setIdDemandInfo`,
149           `setIdStrictness`
150 \end{code}
151
152 %************************************************************************
153 %*                                                                      *
154 \subsection{Basic Id manipulation}
155 %*                                                                      *
156 %************************************************************************
157
158 \begin{code}
159 idName   :: Id -> Name
160 idName    = Var.varName
161
162 idUnique :: Id -> Unique
163 idUnique  = Var.varUnique
164
165 idType   :: Id -> Kind
166 idType    = Var.varType
167
168 setIdName :: Id -> Name -> Id
169 setIdName = Var.setVarName
170
171 setIdUnique :: Id -> Unique -> Id
172 setIdUnique = Var.setVarUnique
173
174 -- | Not only does this set the 'Id' 'Type', it also evaluates the type to try and
175 -- reduce space usage
176 setIdType :: Id -> Type -> Id
177 setIdType id ty = seqType ty `seq` Var.setVarType id ty
178
179 setIdExported :: Id -> Id
180 setIdExported = Var.setIdExported
181
182 setIdNotExported :: Id -> Id
183 setIdNotExported = Var.setIdNotExported
184
185 localiseId :: Id -> Id
186 -- Make an with the same unique and type as the
187 -- incoming Id, but with an *Internal* Name and *LocalId* flavour
188 localiseId id
189   | ASSERT( isId id ) isLocalId id && isInternalName name
190   = id
191   | otherwise
192   = mkLocalIdWithInfo (localiseName name) (idType id) (idInfo id)
193   where
194     name = idName id
195
196 lazySetIdInfo :: Id -> IdInfo -> Id
197 lazySetIdInfo = Var.lazySetIdInfo
198
199 setIdInfo :: Id -> IdInfo -> Id
200 setIdInfo id info = seqIdInfo info `seq` (lazySetIdInfo id info)
201         -- Try to avoid spack leaks by seq'ing
202
203 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
204 modifyIdInfo fn id = setIdInfo id (fn (idInfo id))
205
206 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
207 maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
208 maybeModifyIdInfo (Just new_info) id = lazySetIdInfo id new_info
209 maybeModifyIdInfo Nothing         id = id
210 \end{code}
211
212 %************************************************************************
213 %*                                                                      *
214 \subsection{Simple Id construction}
215 %*                                                                      *
216 %************************************************************************
217
218 Absolutely all Ids are made by mkId.  It is just like Var.mkId,
219 but in addition it pins free-tyvar-info onto the Id's type,
220 where it can easily be found.
221
222 Note [Free type variables]
223 ~~~~~~~~~~~~~~~~~~~~~~~~~~
224 At one time we cached the free type variables of the type of an Id
225 at the root of the type in a TyNote.  The idea was to avoid repeating
226 the free-type-variable calculation.  But it turned out to slow down
227 the compiler overall. I don't quite know why; perhaps finding free
228 type variables of an Id isn't all that common whereas applying a
229 substitution (which changes the free type variables) is more common.
230 Anyway, we removed it in March 2008.
231
232 \begin{code}
233 -- | For an explanation of global vs. local 'Id's, see "Var#globalvslocal"
234 mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
235 mkGlobalId = Var.mkGlobalVar
236
237 -- | Make a global 'Id' without any extra information at all
238 mkVanillaGlobal :: Name -> Type -> Id
239 mkVanillaGlobal name ty = mkVanillaGlobalWithInfo name ty vanillaIdInfo
240
241 -- | Make a global 'Id' with no global information but some generic 'IdInfo'
242 mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
243 mkVanillaGlobalWithInfo = mkGlobalId VanillaId
244
245
246 -- | For an explanation of global vs. local 'Id's, see "Var#globalvslocal"
247 mkLocalId :: Name -> Type -> Id
248 mkLocalId name ty = mkLocalIdWithInfo name ty
249                          (vanillaIdInfo `setOneShotInfo` typeOneShot ty)
250
251 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
252 mkLocalIdWithInfo name ty info = Var.mkLocalVar VanillaId name ty info
253         -- Note [Free type variables]
254
255 -- | Create a local 'Id' that is marked as exported.
256 -- This prevents things attached to it from being removed as dead code.
257 -- See Note [Exported LocalIds]
258 mkExportedLocalId :: IdDetails -> Name -> Type -> Id
259 mkExportedLocalId details name ty = Var.mkExportedLocalVar details name ty vanillaIdInfo
260         -- Note [Free type variables]
261
262
263 -- | Create a system local 'Id'. These are local 'Id's (see "Var#globalvslocal")
264 -- that are created by the compiler out of thin air
265 mkSysLocal :: FastString -> Unique -> Type -> Id
266 mkSysLocal fs uniq ty = mkLocalId (mkSystemVarName uniq fs) ty
267
268 mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id
269 mkSysLocalM fs ty = getUniqueM >>= (\uniq -> return (mkSysLocal fs uniq ty))
270
271
272 -- | Create a user local 'Id'. These are local 'Id's (see "Var#globalvslocal") with a name and location that the user might recognize
273 mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
274 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
275
276 mkUserLocalM :: MonadUnique m => OccName -> Type -> SrcSpan -> m Id
277 mkUserLocalM occ ty loc = getUniqueM >>= (\uniq -> return (mkUserLocal occ uniq ty loc))
278
279 mkDerivedLocalM :: MonadUnique m => (OccName -> OccName) -> Id -> Type -> m Id
280 mkDerivedLocalM deriv_name id ty
281     = getUniqueM >>= (\uniq -> return (mkLocalId (mkDerivedInternalName deriv_name uniq (getName id)) ty))
282
283 mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name
284 mkWiredInIdName mod fs uniq id
285  = mkWiredInName mod (mkOccNameFS varName fs) uniq (AnId id) UserSyntax
286 \end{code}
287
288 Make some local @Ids@ for a template @CoreExpr@.  These have bogus
289 @Uniques@, but that's OK because the templates are supposed to be
290 instantiated before use.
291
292 \begin{code}
293 -- | Workers get local names. "CoreTidy" will externalise these if necessary
294 mkWorkerId :: Unique -> Id -> Type -> Id
295 mkWorkerId uniq unwrkr ty
296   = mkLocalId (mkDerivedInternalName mkWorkerOcc uniq (getName unwrkr)) ty
297
298 -- | Create a /template local/: a family of system local 'Id's in bijection with @Int@s, typically used in unfoldings
299 mkTemplateLocal :: Int -> Type -> Id
300 mkTemplateLocal i ty = mkSysLocal (fsLit "tpl") (mkBuiltinUnique i) ty
301
302 -- | Create a template local for a series of types
303 mkTemplateLocals :: [Type] -> [Id]
304 mkTemplateLocals = mkTemplateLocalsNum 1
305
306 -- | Create a template local for a series of type, but start from a specified template local
307 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
308 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
309 \end{code}
310
311 Note [Exported LocalIds]
312 ~~~~~~~~~~~~~~~~~~~~~~~~
313 We use mkExportedLocalId for things like
314  - Dictionary functions (DFunId)
315  - Wrapper and matcher Ids for pattern synonyms
316  - Default methods for classes
317  - etc
318
319 They marked as "exported" in the sense that they should be kept alive
320 even if apparently unused in other bindings, and not dropped as dead
321 code by the occurrence analyser.  (But "exported" here does not mean
322 "brought into lexical scope by an import declaration". Indeed these
323 things are always internal Ids that the user never sees.)
324
325 It's very important that they are *LocalIds*, not GlobalIs, for lots
326 of reasons:
327
328  * We want to treat them as free variables for the purpose of
329    dependency analysis (e.g. CoreFVs.exprFreeVars).
330
331  * Look them up in the current substitution when we come across
332    occurrences of them (in Subst.lookupIdSubst)
333
334  * Ensure that for dfuns that the specialiser does not float dict uses
335    above their defns, which would prevent good simplifications happening.
336
337  * The strictness analyser treats a occurrence of a GlobalId as
338    imported and assumes it contains strictness in its IdInfo, which
339    isn't true if the thing is bound in the same module as the
340    occurrence.
341
342 In CoreTidy we must make all these LocalIds into GlobalIds, so that in
343 importing modules (in --make mode) we treat them as properly global.
344 That is what is happening in, say tidy_insts in TidyPgm.
345
346 %************************************************************************
347 %*                                                                      *
348 \subsection{Special Ids}
349 %*                                                                      *
350 %************************************************************************
351
352 \begin{code}
353 -- | If the 'Id' is that for a record selector, extract the 'sel_tycon' and label. Panic otherwise
354 recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
355 recordSelectorFieldLabel id
356   = case Var.idDetails id of
357         RecSelId { sel_tycon = tycon } -> (tycon, idName id)
358         _ -> panic "recordSelectorFieldLabel"
359
360 isRecordSelector        :: Id -> Bool
361 isNaughtyRecordSelector :: Id -> Bool
362 isPrimOpId              :: Id -> Bool
363 isFCallId               :: Id -> Bool
364 isDataConWorkId         :: Id -> Bool
365 isDFunId                :: Id -> Bool
366
367 isClassOpId_maybe       :: Id -> Maybe Class
368 isPrimOpId_maybe        :: Id -> Maybe PrimOp
369 isFCallId_maybe         :: Id -> Maybe ForeignCall
370 isDataConWorkId_maybe   :: Id -> Maybe DataCon
371
372 isRecordSelector id = case Var.idDetails id of
373                         RecSelId {}  -> True
374                         _               -> False
375
376 isNaughtyRecordSelector id = case Var.idDetails id of
377                         RecSelId { sel_naughty = n } -> n
378                         _                               -> False
379
380 isClassOpId_maybe id = case Var.idDetails id of
381                         ClassOpId cls -> Just cls
382                         _other        -> Nothing
383
384 isPrimOpId id = case Var.idDetails id of
385                         PrimOpId _ -> True
386                         _          -> False
387
388 isDFunId id = case Var.idDetails id of
389                         DFunId {} -> True
390                         _         -> False
391
392 dfunNSilent :: Id -> Int
393 dfunNSilent id = case Var.idDetails id of
394                    DFunId ns _ -> ns
395                    _ -> pprPanic "dfunSilent: not a dfun:" (ppr id)
396
397 isPrimOpId_maybe id = case Var.idDetails id of
398                         PrimOpId op -> Just op
399                         _           -> Nothing
400
401 isFCallId id = case Var.idDetails id of
402                         FCallId _ -> True
403                         _         -> False
404
405 isFCallId_maybe id = case Var.idDetails id of
406                         FCallId call -> Just call
407                         _            -> Nothing
408
409 isDataConWorkId id = case Var.idDetails id of
410                         DataConWorkId _ -> True
411                         _               -> False
412
413 isDataConWorkId_maybe id = case Var.idDetails id of
414                         DataConWorkId con -> Just con
415                         _                 -> Nothing
416
417 isDataConId_maybe :: Id -> Maybe DataCon
418 isDataConId_maybe id = case Var.idDetails id of
419                          DataConWorkId con -> Just con
420                          DataConWrapId con -> Just con
421                          _                 -> Nothing
422
423 idDataCon :: Id -> DataCon
424 -- ^ Get from either the worker or the wrapper 'Id' to the 'DataCon'. Currently used only in the desugarer.
425 --
426 -- INVARIANT: @idDataCon (dataConWrapId d) = d@: remember, 'dataConWrapId' can return either the wrapper or the worker
427 idDataCon id = isDataConId_maybe id `orElse` pprPanic "idDataCon" (ppr id)
428
429 hasNoBinding :: Id -> Bool
430 -- ^ Returns @True@ of an 'Id' which may not have a
431 -- binding, even though it is defined in this module.
432
433 -- Data constructor workers used to be things of this kind, but
434 -- they aren't any more.  Instead, we inject a binding for
435 -- them at the CorePrep stage.
436 -- EXCEPT: unboxed tuples, which definitely have no binding
437 hasNoBinding id = case Var.idDetails id of
438                         PrimOpId _       -> True        -- See Note [Primop wrappers]
439                         FCallId _        -> True
440                         DataConWorkId dc -> isUnboxedTupleCon dc
441                         _                -> False
442
443 isImplicitId :: Id -> Bool
444 -- ^ 'isImplicitId' tells whether an 'Id's info is implied by other
445 -- declarations, so we don't need to put its signature in an interface
446 -- file, even if it's mentioned in some other interface unfolding.
447 isImplicitId id
448   = case Var.idDetails id of
449         FCallId {}       -> True
450         ClassOpId {}     -> True
451         PrimOpId {}      -> True
452         DataConWorkId {} -> True
453         DataConWrapId {} -> True
454                 -- These are are implied by their type or class decl;
455                 -- remember that all type and class decls appear in the interface file.
456                 -- The dfun id is not an implicit Id; it must *not* be omitted, because
457                 -- it carries version info for the instance decl
458         _               -> False
459
460 idIsFrom :: Module -> Id -> Bool
461 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
462 \end{code}
463
464 Note [Primop wrappers]
465 ~~~~~~~~~~~~~~~~~~~~~~
466 Currently hasNoBinding claims that PrimOpIds don't have a curried
467 function definition.  But actually they do, in GHC.PrimopWrappers,
468 which is auto-generated from prelude/primops.txt.pp.  So actually, hasNoBinding
469 could return 'False' for PrimOpIds.
470
471 But we'd need to add something in CoreToStg to swizzle any unsaturated
472 applications of GHC.Prim.plusInt# to GHC.PrimopWrappers.plusInt#.
473
474 Nota Bene: GHC.PrimopWrappers is needed *regardless*, because it's
475 used by GHCi, which does not implement primops direct at all.
476
477
478
479 \begin{code}
480 isDeadBinder :: Id -> Bool
481 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
482                   | otherwise = False   -- TyVars count as not dead
483 \end{code}
484
485 %************************************************************************
486 %*                                                                      *
487               Evidence variables
488 %*                                                                      *
489 %************************************************************************
490
491 \begin{code}
492 isEvVar :: Var -> Bool
493 isEvVar var = isPredTy (varType var)
494
495 isDictId :: Id -> Bool
496 isDictId id = isDictTy (idType id)
497 \end{code}
498
499 %************************************************************************
500 %*                                                                      *
501 \subsection{IdInfo stuff}
502 %*                                                                      *
503 %************************************************************************
504
505 \begin{code}
506         ---------------------------------
507         -- ARITY
508 idArity :: Id -> Arity
509 idArity id = arityInfo (idInfo id)
510
511 setIdArity :: Id -> Arity -> Id
512 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
513
514 idCallArity :: Id -> Arity
515 idCallArity id = callArityInfo (idInfo id)
516
517 setIdCallArity :: Id -> Arity -> Id
518 setIdCallArity id arity = modifyIdInfo (`setCallArityInfo` arity) id
519
520 idRepArity :: Id -> RepArity
521 idRepArity x = typeRepArity (idArity x) (idType x)
522
523 -- | Returns true if an application to n args would diverge
524 isBottomingId :: Id -> Bool
525 isBottomingId id = isBottomingSig (idStrictness id)
526
527 idStrictness :: Id -> StrictSig
528 idStrictness id = strictnessInfo (idInfo id)
529
530 setIdStrictness :: Id -> StrictSig -> Id
531 setIdStrictness id sig = modifyIdInfo (`setStrictnessInfo` sig) id
532
533 zapIdStrictness :: Id -> Id
534 zapIdStrictness id = modifyIdInfo (`setStrictnessInfo` nopSig) id
535
536 -- | This predicate says whether the 'Id' has a strict demand placed on it or
537 -- has a type such that it can always be evaluated strictly (i.e an
538 -- unlifted type, as of GHC 7.6).  We need to
539 -- check separately whether the 'Id' has a so-called \"strict type\" because if
540 -- the demand for the given @id@ hasn't been computed yet but @id@ has a strict
541 -- type, we still want @isStrictId id@ to be @True@.
542 isStrictId :: Id -> Bool
543 isStrictId id
544   = ASSERT2( isId id, text "isStrictId: not an id: " <+> ppr id )
545            (isStrictType (idType id)) ||
546            -- Take the best of both strictnesses - old and new               
547            (isStrictDmd (idDemandInfo id))
548
549         ---------------------------------
550         -- UNFOLDING
551 idUnfolding :: Id -> Unfolding
552 -- Do not expose the unfolding of a loop breaker!
553 idUnfolding id
554   | isStrongLoopBreaker (occInfo info) = NoUnfolding
555   | otherwise                          = unfoldingInfo info
556   where
557     info = idInfo id
558
559 realIdUnfolding :: Id -> Unfolding
560 -- Expose the unfolding if there is one, including for loop breakers
561 realIdUnfolding id = unfoldingInfo (idInfo id)
562
563 setIdUnfoldingLazily :: Id -> Unfolding -> Id
564 setIdUnfoldingLazily id unfolding = modifyIdInfo (`setUnfoldingInfoLazily` unfolding) id
565
566 setIdUnfolding :: Id -> Unfolding -> Id
567 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
568
569 idDemandInfo       :: Id -> Demand
570 idDemandInfo       id = demandInfo (idInfo id)
571
572 setIdDemandInfo :: Id -> Demand -> Id
573 setIdDemandInfo id dmd = modifyIdInfo (`setDemandInfo` dmd) id
574
575         ---------------------------------
576         -- SPECIALISATION
577
578 -- See Note [Specialisations and RULES in IdInfo] in IdInfo.lhs
579
580 idSpecialisation :: Id -> SpecInfo
581 idSpecialisation id = specInfo (idInfo id)
582
583 idCoreRules :: Id -> [CoreRule]
584 idCoreRules id = specInfoRules (idSpecialisation id)
585
586 idHasRules :: Id -> Bool
587 idHasRules id = not (isEmptySpecInfo (idSpecialisation id))
588
589 setIdSpecialisation :: Id -> SpecInfo -> Id
590 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
591
592         ---------------------------------
593         -- CAF INFO
594 idCafInfo :: Id -> CafInfo
595 idCafInfo id = cafInfo (idInfo id)
596
597 setIdCafInfo :: Id -> CafInfo -> Id
598 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
599
600         ---------------------------------
601         -- Occcurrence INFO
602 idOccInfo :: Id -> OccInfo
603 idOccInfo id = occInfo (idInfo id)
604
605 setIdOccInfo :: Id -> OccInfo -> Id
606 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
607
608 zapIdOccInfo :: Id -> Id
609 zapIdOccInfo b = b `setIdOccInfo` NoOccInfo
610 \end{code}
611
612
613         ---------------------------------
614         -- INLINING
615 The inline pragma tells us to be very keen to inline this Id, but it's still
616 OK not to if optimisation is switched off.
617
618 \begin{code}
619 idInlinePragma :: Id -> InlinePragma
620 idInlinePragma id = inlinePragInfo (idInfo id)
621
622 setInlinePragma :: Id -> InlinePragma -> Id
623 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
624
625 modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
626 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
627
628 idInlineActivation :: Id -> Activation
629 idInlineActivation id = inlinePragmaActivation (idInlinePragma id)
630
631 setInlineActivation :: Id -> Activation -> Id
632 setInlineActivation id act = modifyInlinePragma id (\prag -> setInlinePragmaActivation prag act)
633
634 idRuleMatchInfo :: Id -> RuleMatchInfo
635 idRuleMatchInfo id = inlinePragmaRuleMatchInfo (idInlinePragma id)
636
637 isConLikeId :: Id -> Bool
638 isConLikeId id = isDataConWorkId id || isConLike (idRuleMatchInfo id)
639 \end{code}
640
641
642         ---------------------------------
643         -- ONE-SHOT LAMBDAS
644 \begin{code}
645 idOneShotInfo :: Id -> OneShotInfo
646 idOneShotInfo id = oneShotInfo (idInfo id)
647
648 -- | Returns whether the lambda associated with the 'Id' is certainly applied at most once
649 -- This one is the "business end", called externally.
650 -- It works on type variables as well as Ids, returning True
651 -- Its main purpose is to encapsulate the Horrible State Hack
652 isOneShotBndr :: Var -> Bool
653 isOneShotBndr var
654   | isTyVar var = True
655   | otherwise   = isOneShotLambda var
656
657 -- | Should we apply the state hack to values of this 'Type'?
658 stateHackOneShot :: OneShotInfo
659 stateHackOneShot = OneShotLam         -- Or maybe ProbOneShot?
660
661 typeOneShot :: Type -> OneShotInfo
662 typeOneShot ty
663    | isStateHackType ty = stateHackOneShot
664    | otherwise          = NoOneShotInfo
665
666 isStateHackType :: Type -> Bool
667 isStateHackType ty
668   | opt_NoStateHack
669   = False
670   | otherwise
671   = case tyConAppTyCon_maybe ty of
672         Just tycon -> tycon == statePrimTyCon
673         _          -> False
674         -- This is a gross hack.  It claims that
675         -- every function over realWorldStatePrimTy is a one-shot
676         -- function.  This is pretty true in practice, and makes a big
677         -- difference.  For example, consider
678         --      a `thenST` \ r -> ...E...
679         -- The early full laziness pass, if it doesn't know that r is one-shot
680         -- will pull out E (let's say it doesn't mention r) to give
681         --      let lvl = E in a `thenST` \ r -> ...lvl...
682         -- When `thenST` gets inlined, we end up with
683         --      let lvl = E in \s -> case a s of (r, s') -> ...lvl...
684         -- and we don't re-inline E.
685         --
686         -- It would be better to spot that r was one-shot to start with, but
687         -- I don't want to rely on that.
688         --
689         -- Another good example is in fill_in in PrelPack.lhs.  We should be able to
690         -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
691
692
693 -- | Returns whether the lambda associated with the 'Id' is certainly applied at most once.
694 -- You probably want to use 'isOneShotBndr' instead
695 isOneShotLambda :: Id -> Bool
696 isOneShotLambda id = case idOneShotInfo id of
697                        OneShotLam -> True
698                        _          -> False
699
700 isProbablyOneShotLambda :: Id -> Bool
701 isProbablyOneShotLambda id = case idOneShotInfo id of
702                                OneShotLam    -> True
703                                ProbOneShot   -> True
704                                NoOneShotInfo -> False
705
706 setOneShotLambda :: Id -> Id
707 setOneShotLambda id = modifyIdInfo (`setOneShotInfo` OneShotLam) id
708
709 clearOneShotLambda :: Id -> Id
710 clearOneShotLambda id = modifyIdInfo (`setOneShotInfo` NoOneShotInfo) id
711
712 setIdOneShotInfo :: Id -> OneShotInfo -> Id
713 setIdOneShotInfo id one_shot = modifyIdInfo (`setOneShotInfo` one_shot) id
714
715 updOneShotInfo :: Id -> OneShotInfo -> Id
716 -- Combine the info in the Id with new info
717 updOneShotInfo id one_shot
718   | do_upd    = setIdOneShotInfo id one_shot
719   | otherwise = id
720   where
721     do_upd = case (idOneShotInfo id, one_shot) of
722                 (NoOneShotInfo, _) -> True
723                 (OneShotLam,    _) -> False
724                 (_, NoOneShotInfo) -> False
725                 _                  -> True
726
727 -- The OneShotLambda functions simply fiddle with the IdInfo flag
728 -- But watch out: this may change the type of something else
729 --      f = \x -> e
730 -- If we change the one-shot-ness of x, f's type changes
731 \end{code}
732
733 \begin{code}
734 zapInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
735 zapInfo zapper id = maybeModifyIdInfo (zapper (idInfo id)) id
736
737 zapLamIdInfo :: Id -> Id
738 zapLamIdInfo = zapInfo zapLamInfo
739
740 zapFragileIdInfo :: Id -> Id
741 zapFragileIdInfo = zapInfo zapFragileInfo 
742
743 zapDemandIdInfo :: Id -> Id
744 zapDemandIdInfo = zapInfo zapDemandInfo
745 \end{code}
746
747 Note [transferPolyIdInfo]
748 ~~~~~~~~~~~~~~~~~~~~~~~~~
749 This transfer is used in two places:
750         FloatOut (long-distance let-floating)
751         SimplUtils.abstractFloats (short-distance let-floating)
752
753 Consider the short-distance let-floating:
754
755    f = /\a. let g = rhs in ...
756
757 Then if we float thus
758
759    g' = /\a. rhs
760    f = /\a. ...[g' a/g]....
761
762 we *do not* want to lose g's
763   * strictness information
764   * arity
765   * inline pragma (though that is bit more debatable)
766   * occurrence info
767
768 Mostly this is just an optimisation, but it's *vital* to
769 transfer the occurrence info.  Consider
770
771    NonRec { f = /\a. let Rec { g* = ..g.. } in ... }
772
773 where the '*' means 'LoopBreaker'.  Then if we float we must get
774
775    Rec { g'* = /\a. ...(g' a)... }
776    NonRec { f = /\a. ...[g' a/g]....}
777
778 where g' is also marked as LoopBreaker.  If not, terrible things
779 can happen if we re-simplify the binding (and the Simplifier does
780 sometimes simplify a term twice); see Trac #4345.
781
782 It's not so simple to retain
783   * worker info
784   * rules
785 so we simply discard those.  Sooner or later this may bite us.
786
787 If we abstract wrt one or more *value* binders, we must modify the
788 arity and strictness info before transferring it.  E.g.
789       f = \x. e
790 -->
791       g' = \y. \x. e
792       + substitute (g' y) for g
793 Notice that g' has an arity one more than the original g
794
795 \begin{code}
796 transferPolyIdInfo :: Id        -- Original Id
797                    -> [Var]     -- Abstract wrt these variables
798                    -> Id        -- New Id
799                    -> Id
800 transferPolyIdInfo old_id abstract_wrt new_id
801   = modifyIdInfo transfer new_id
802   where
803     arity_increase = count isId abstract_wrt    -- Arity increases by the
804                                                 -- number of value binders
805
806     old_info        = idInfo old_id
807     old_arity       = arityInfo old_info
808     old_inline_prag = inlinePragInfo old_info
809     old_occ_info    = occInfo old_info
810     new_arity       = old_arity + arity_increase
811
812     old_strictness  = strictnessInfo old_info
813     new_strictness  = increaseStrictSigArity arity_increase old_strictness
814
815     transfer new_info = new_info `setArityInfo` new_arity
816                                  `setInlinePragInfo` old_inline_prag
817                                  `setOccInfo` old_occ_info
818                                  `setStrictnessInfo` new_strictness
819 \end{code}