b180dc7f9abb5f16f6950fe7ab2fdbf17a139d6e
[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 mkExportedLocalId :: Name -> Type -> Id
258 mkExportedLocalId name ty = Var.mkExportedLocalVar VanillaId name ty vanillaIdInfo
259         -- Note [Free type variables]
260
261
262 -- | Create a system local 'Id'. These are local 'Id's (see "Var#globalvslocal")
263 -- that are created by the compiler out of thin air
264 mkSysLocal :: FastString -> Unique -> Type -> Id
265 mkSysLocal fs uniq ty = mkLocalId (mkSystemVarName uniq fs) ty
266
267 mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id
268 mkSysLocalM fs ty = getUniqueM >>= (\uniq -> return (mkSysLocal fs uniq ty))
269
270
271 -- | Create a user local 'Id'. These are local 'Id's (see "Var#globalvslocal") with a name and location that the user might recognize
272 mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
273 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
274
275 mkUserLocalM :: MonadUnique m => OccName -> Type -> SrcSpan -> m Id
276 mkUserLocalM occ ty loc = getUniqueM >>= (\uniq -> return (mkUserLocal occ uniq ty loc))
277
278 mkDerivedLocalM :: MonadUnique m => (OccName -> OccName) -> Id -> Type -> m Id
279 mkDerivedLocalM deriv_name id ty
280     = getUniqueM >>= (\uniq -> return (mkLocalId (mkDerivedInternalName deriv_name uniq (getName id)) ty))
281
282 mkWiredInIdName :: Module -> FastString -> Unique -> Id -> Name
283 mkWiredInIdName mod fs uniq id
284  = mkWiredInName mod (mkOccNameFS varName fs) uniq (AnId id) UserSyntax
285 \end{code}
286
287 Make some local @Ids@ for a template @CoreExpr@.  These have bogus
288 @Uniques@, but that's OK because the templates are supposed to be
289 instantiated before use.
290
291 \begin{code}
292 -- | Workers get local names. "CoreTidy" will externalise these if necessary
293 mkWorkerId :: Unique -> Id -> Type -> Id
294 mkWorkerId uniq unwrkr ty
295   = mkLocalId (mkDerivedInternalName mkWorkerOcc uniq (getName unwrkr)) ty
296
297 -- | Create a /template local/: a family of system local 'Id's in bijection with @Int@s, typically used in unfoldings
298 mkTemplateLocal :: Int -> Type -> Id
299 mkTemplateLocal i ty = mkSysLocal (fsLit "tpl") (mkBuiltinUnique i) ty
300
301 -- | Create a template local for a series of types
302 mkTemplateLocals :: [Type] -> [Id]
303 mkTemplateLocals = mkTemplateLocalsNum 1
304
305 -- | Create a template local for a series of type, but start from a specified template local
306 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
307 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
308 \end{code}
309
310
311 %************************************************************************
312 %*                                                                      *
313 \subsection{Special Ids}
314 %*                                                                      *
315 %************************************************************************
316
317 \begin{code}
318 -- | If the 'Id' is that for a record selector, extract the 'sel_tycon' and label. Panic otherwise
319 recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
320 recordSelectorFieldLabel id
321   = case Var.idDetails id of
322         RecSelId { sel_tycon = tycon } -> (tycon, idName id)
323         _ -> panic "recordSelectorFieldLabel"
324
325 isRecordSelector        :: Id -> Bool
326 isNaughtyRecordSelector :: Id -> Bool
327 isPrimOpId              :: Id -> Bool
328 isFCallId               :: Id -> Bool
329 isDataConWorkId         :: Id -> Bool
330 isDFunId                :: Id -> Bool
331
332 isClassOpId_maybe       :: Id -> Maybe Class
333 isPrimOpId_maybe        :: Id -> Maybe PrimOp
334 isFCallId_maybe         :: Id -> Maybe ForeignCall
335 isDataConWorkId_maybe   :: Id -> Maybe DataCon
336
337 isRecordSelector id = case Var.idDetails id of
338                         RecSelId {}  -> True
339                         _               -> False
340
341 isNaughtyRecordSelector id = case Var.idDetails id of
342                         RecSelId { sel_naughty = n } -> n
343                         _                               -> False
344
345 isClassOpId_maybe id = case Var.idDetails id of
346                         ClassOpId cls -> Just cls
347                         _other        -> Nothing
348
349 isPrimOpId id = case Var.idDetails id of
350                         PrimOpId _ -> True
351                         _          -> False
352
353 isDFunId id = case Var.idDetails id of
354                         DFunId {} -> True
355                         _         -> False
356
357 dfunNSilent :: Id -> Int
358 dfunNSilent id = case Var.idDetails id of
359                    DFunId ns _ -> ns
360                    _ -> pprPanic "dfunSilent: not a dfun:" (ppr id)
361
362 isPrimOpId_maybe id = case Var.idDetails id of
363                         PrimOpId op -> Just op
364                         _           -> Nothing
365
366 isFCallId id = case Var.idDetails id of
367                         FCallId _ -> True
368                         _         -> False
369
370 isFCallId_maybe id = case Var.idDetails id of
371                         FCallId call -> Just call
372                         _            -> Nothing
373
374 isDataConWorkId id = case Var.idDetails id of
375                         DataConWorkId _ -> True
376                         _               -> False
377
378 isDataConWorkId_maybe id = case Var.idDetails id of
379                         DataConWorkId con -> Just con
380                         _                 -> Nothing
381
382 isDataConId_maybe :: Id -> Maybe DataCon
383 isDataConId_maybe id = case Var.idDetails id of
384                          DataConWorkId con -> Just con
385                          DataConWrapId con -> Just con
386                          _                 -> Nothing
387
388 idDataCon :: Id -> DataCon
389 -- ^ Get from either the worker or the wrapper 'Id' to the 'DataCon'. Currently used only in the desugarer.
390 --
391 -- INVARIANT: @idDataCon (dataConWrapId d) = d@: remember, 'dataConWrapId' can return either the wrapper or the worker
392 idDataCon id = isDataConId_maybe id `orElse` pprPanic "idDataCon" (ppr id)
393
394 hasNoBinding :: Id -> Bool
395 -- ^ Returns @True@ of an 'Id' which may not have a
396 -- binding, even though it is defined in this module.
397
398 -- Data constructor workers used to be things of this kind, but
399 -- they aren't any more.  Instead, we inject a binding for
400 -- them at the CorePrep stage.
401 -- EXCEPT: unboxed tuples, which definitely have no binding
402 hasNoBinding id = case Var.idDetails id of
403                         PrimOpId _       -> True        -- See Note [Primop wrappers]
404                         FCallId _        -> True
405                         DataConWorkId dc -> isUnboxedTupleCon dc
406                         _                -> False
407
408 isImplicitId :: Id -> Bool
409 -- ^ 'isImplicitId' tells whether an 'Id's info is implied by other
410 -- declarations, so we don't need to put its signature in an interface
411 -- file, even if it's mentioned in some other interface unfolding.
412 isImplicitId id
413   = case Var.idDetails id of
414         FCallId {}       -> True
415         ClassOpId {}     -> True
416         PrimOpId {}      -> True
417         DataConWorkId {} -> True
418         DataConWrapId {} -> True
419                 -- These are are implied by their type or class decl;
420                 -- remember that all type and class decls appear in the interface file.
421                 -- The dfun id is not an implicit Id; it must *not* be omitted, because
422                 -- it carries version info for the instance decl
423         _               -> False
424
425 idIsFrom :: Module -> Id -> Bool
426 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
427 \end{code}
428
429 Note [Primop wrappers]
430 ~~~~~~~~~~~~~~~~~~~~~~
431 Currently hasNoBinding claims that PrimOpIds don't have a curried
432 function definition.  But actually they do, in GHC.PrimopWrappers,
433 which is auto-generated from prelude/primops.txt.pp.  So actually, hasNoBinding
434 could return 'False' for PrimOpIds.
435
436 But we'd need to add something in CoreToStg to swizzle any unsaturated
437 applications of GHC.Prim.plusInt# to GHC.PrimopWrappers.plusInt#.
438
439 Nota Bene: GHC.PrimopWrappers is needed *regardless*, because it's
440 used by GHCi, which does not implement primops direct at all.
441
442
443
444 \begin{code}
445 isDeadBinder :: Id -> Bool
446 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
447                   | otherwise = False   -- TyVars count as not dead
448 \end{code}
449
450 %************************************************************************
451 %*                                                                      *
452               Evidence variables
453 %*                                                                      *
454 %************************************************************************
455
456 \begin{code}
457 isEvVar :: Var -> Bool
458 isEvVar var = isPredTy (varType var)
459
460 isDictId :: Id -> Bool
461 isDictId id = isDictTy (idType id)
462 \end{code}
463
464 %************************************************************************
465 %*                                                                      *
466 \subsection{IdInfo stuff}
467 %*                                                                      *
468 %************************************************************************
469
470 \begin{code}
471         ---------------------------------
472         -- ARITY
473 idArity :: Id -> Arity
474 idArity id = arityInfo (idInfo id)
475
476 setIdArity :: Id -> Arity -> Id
477 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
478
479 idCallArity :: Id -> Arity
480 idCallArity id = callArityInfo (idInfo id)
481
482 setIdCallArity :: Id -> Arity -> Id
483 setIdCallArity id arity = modifyIdInfo (`setCallArityInfo` arity) id
484
485 idRepArity :: Id -> RepArity
486 idRepArity x = typeRepArity (idArity x) (idType x)
487
488 -- | Returns true if an application to n args would diverge
489 isBottomingId :: Id -> Bool
490 isBottomingId id = isBottomingSig (idStrictness id)
491
492 idStrictness :: Id -> StrictSig
493 idStrictness id = strictnessInfo (idInfo id)
494
495 setIdStrictness :: Id -> StrictSig -> Id
496 setIdStrictness id sig = modifyIdInfo (`setStrictnessInfo` sig) id
497
498 zapIdStrictness :: Id -> Id
499 zapIdStrictness id = modifyIdInfo (`setStrictnessInfo` nopSig) id
500
501 -- | This predicate says whether the 'Id' has a strict demand placed on it or
502 -- has a type such that it can always be evaluated strictly (i.e an
503 -- unlifted type, as of GHC 7.6).  We need to
504 -- check separately whether the 'Id' has a so-called \"strict type\" because if
505 -- the demand for the given @id@ hasn't been computed yet but @id@ has a strict
506 -- type, we still want @isStrictId id@ to be @True@.
507 isStrictId :: Id -> Bool
508 isStrictId id
509   = ASSERT2( isId id, text "isStrictId: not an id: " <+> ppr id )
510            (isStrictType (idType id)) ||
511            -- Take the best of both strictnesses - old and new               
512            (isStrictDmd (idDemandInfo id))
513
514         ---------------------------------
515         -- UNFOLDING
516 idUnfolding :: Id -> Unfolding
517 -- Do not expose the unfolding of a loop breaker!
518 idUnfolding id
519   | isStrongLoopBreaker (occInfo info) = NoUnfolding
520   | otherwise                          = unfoldingInfo info
521   where
522     info = idInfo id
523
524 realIdUnfolding :: Id -> Unfolding
525 -- Expose the unfolding if there is one, including for loop breakers
526 realIdUnfolding id = unfoldingInfo (idInfo id)
527
528 setIdUnfoldingLazily :: Id -> Unfolding -> Id
529 setIdUnfoldingLazily id unfolding = modifyIdInfo (`setUnfoldingInfoLazily` unfolding) id
530
531 setIdUnfolding :: Id -> Unfolding -> Id
532 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
533
534 idDemandInfo       :: Id -> Demand
535 idDemandInfo       id = demandInfo (idInfo id)
536
537 setIdDemandInfo :: Id -> Demand -> Id
538 setIdDemandInfo id dmd = modifyIdInfo (`setDemandInfo` dmd) id
539
540         ---------------------------------
541         -- SPECIALISATION
542
543 -- See Note [Specialisations and RULES in IdInfo] in IdInfo.lhs
544
545 idSpecialisation :: Id -> SpecInfo
546 idSpecialisation id = specInfo (idInfo id)
547
548 idCoreRules :: Id -> [CoreRule]
549 idCoreRules id = specInfoRules (idSpecialisation id)
550
551 idHasRules :: Id -> Bool
552 idHasRules id = not (isEmptySpecInfo (idSpecialisation id))
553
554 setIdSpecialisation :: Id -> SpecInfo -> Id
555 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
556
557         ---------------------------------
558         -- CAF INFO
559 idCafInfo :: Id -> CafInfo
560 idCafInfo id = cafInfo (idInfo id)
561
562 setIdCafInfo :: Id -> CafInfo -> Id
563 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
564
565         ---------------------------------
566         -- Occcurrence INFO
567 idOccInfo :: Id -> OccInfo
568 idOccInfo id = occInfo (idInfo id)
569
570 setIdOccInfo :: Id -> OccInfo -> Id
571 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
572
573 zapIdOccInfo :: Id -> Id
574 zapIdOccInfo b = b `setIdOccInfo` NoOccInfo
575 \end{code}
576
577
578         ---------------------------------
579         -- INLINING
580 The inline pragma tells us to be very keen to inline this Id, but it's still
581 OK not to if optimisation is switched off.
582
583 \begin{code}
584 idInlinePragma :: Id -> InlinePragma
585 idInlinePragma id = inlinePragInfo (idInfo id)
586
587 setInlinePragma :: Id -> InlinePragma -> Id
588 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
589
590 modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
591 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
592
593 idInlineActivation :: Id -> Activation
594 idInlineActivation id = inlinePragmaActivation (idInlinePragma id)
595
596 setInlineActivation :: Id -> Activation -> Id
597 setInlineActivation id act = modifyInlinePragma id (\prag -> setInlinePragmaActivation prag act)
598
599 idRuleMatchInfo :: Id -> RuleMatchInfo
600 idRuleMatchInfo id = inlinePragmaRuleMatchInfo (idInlinePragma id)
601
602 isConLikeId :: Id -> Bool
603 isConLikeId id = isDataConWorkId id || isConLike (idRuleMatchInfo id)
604 \end{code}
605
606
607         ---------------------------------
608         -- ONE-SHOT LAMBDAS
609 \begin{code}
610 idOneShotInfo :: Id -> OneShotInfo
611 idOneShotInfo id = oneShotInfo (idInfo id)
612
613 -- | Returns whether the lambda associated with the 'Id' is certainly applied at most once
614 -- This one is the "business end", called externally.
615 -- It works on type variables as well as Ids, returning True
616 -- Its main purpose is to encapsulate the Horrible State Hack
617 isOneShotBndr :: Var -> Bool
618 isOneShotBndr var
619   | isTyVar var = True
620   | otherwise   = isOneShotLambda var
621
622 -- | Should we apply the state hack to values of this 'Type'?
623 stateHackOneShot :: OneShotInfo
624 stateHackOneShot = OneShotLam         -- Or maybe ProbOneShot?
625
626 typeOneShot :: Type -> OneShotInfo
627 typeOneShot ty
628    | isStateHackType ty = stateHackOneShot
629    | otherwise          = NoOneShotInfo
630
631 isStateHackType :: Type -> Bool
632 isStateHackType ty
633   | opt_NoStateHack
634   = False
635   | otherwise
636   = case tyConAppTyCon_maybe ty of
637         Just tycon -> tycon == statePrimTyCon
638         _          -> False
639         -- This is a gross hack.  It claims that
640         -- every function over realWorldStatePrimTy is a one-shot
641         -- function.  This is pretty true in practice, and makes a big
642         -- difference.  For example, consider
643         --      a `thenST` \ r -> ...E...
644         -- The early full laziness pass, if it doesn't know that r is one-shot
645         -- will pull out E (let's say it doesn't mention r) to give
646         --      let lvl = E in a `thenST` \ r -> ...lvl...
647         -- When `thenST` gets inlined, we end up with
648         --      let lvl = E in \s -> case a s of (r, s') -> ...lvl...
649         -- and we don't re-inline E.
650         --
651         -- It would be better to spot that r was one-shot to start with, but
652         -- I don't want to rely on that.
653         --
654         -- Another good example is in fill_in in PrelPack.lhs.  We should be able to
655         -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
656
657
658 -- | Returns whether the lambda associated with the 'Id' is certainly applied at most once.
659 -- You probably want to use 'isOneShotBndr' instead
660 isOneShotLambda :: Id -> Bool
661 isOneShotLambda id = case idOneShotInfo id of
662                        OneShotLam -> True
663                        _          -> False
664
665 isProbablyOneShotLambda :: Id -> Bool
666 isProbablyOneShotLambda id = case idOneShotInfo id of
667                                OneShotLam    -> True
668                                ProbOneShot   -> True
669                                NoOneShotInfo -> False
670
671 setOneShotLambda :: Id -> Id
672 setOneShotLambda id = modifyIdInfo (`setOneShotInfo` OneShotLam) id
673
674 clearOneShotLambda :: Id -> Id
675 clearOneShotLambda id = modifyIdInfo (`setOneShotInfo` NoOneShotInfo) id
676
677 setIdOneShotInfo :: Id -> OneShotInfo -> Id
678 setIdOneShotInfo id one_shot = modifyIdInfo (`setOneShotInfo` one_shot) id
679
680 updOneShotInfo :: Id -> OneShotInfo -> Id
681 -- Combine the info in the Id with new info
682 updOneShotInfo id one_shot
683   | do_upd    = setIdOneShotInfo id one_shot
684   | otherwise = id
685   where
686     do_upd = case (idOneShotInfo id, one_shot) of
687                 (NoOneShotInfo, _) -> True
688                 (OneShotLam,    _) -> False
689                 (_, NoOneShotInfo) -> False
690                 _                  -> True
691
692 -- The OneShotLambda functions simply fiddle with the IdInfo flag
693 -- But watch out: this may change the type of something else
694 --      f = \x -> e
695 -- If we change the one-shot-ness of x, f's type changes
696 \end{code}
697
698 \begin{code}
699 zapInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
700 zapInfo zapper id = maybeModifyIdInfo (zapper (idInfo id)) id
701
702 zapLamIdInfo :: Id -> Id
703 zapLamIdInfo = zapInfo zapLamInfo
704
705 zapFragileIdInfo :: Id -> Id
706 zapFragileIdInfo = zapInfo zapFragileInfo 
707
708 zapDemandIdInfo :: Id -> Id
709 zapDemandIdInfo = zapInfo zapDemandInfo
710 \end{code}
711
712 Note [transferPolyIdInfo]
713 ~~~~~~~~~~~~~~~~~~~~~~~~~
714 This transfer is used in two places:
715         FloatOut (long-distance let-floating)
716         SimplUtils.abstractFloats (short-distance let-floating)
717
718 Consider the short-distance let-floating:
719
720    f = /\a. let g = rhs in ...
721
722 Then if we float thus
723
724    g' = /\a. rhs
725    f = /\a. ...[g' a/g]....
726
727 we *do not* want to lose g's
728   * strictness information
729   * arity
730   * inline pragma (though that is bit more debatable)
731   * occurrence info
732
733 Mostly this is just an optimisation, but it's *vital* to
734 transfer the occurrence info.  Consider
735
736    NonRec { f = /\a. let Rec { g* = ..g.. } in ... }
737
738 where the '*' means 'LoopBreaker'.  Then if we float we must get
739
740    Rec { g'* = /\a. ...(g' a)... }
741    NonRec { f = /\a. ...[g' a/g]....}
742
743 where g' is also marked as LoopBreaker.  If not, terrible things
744 can happen if we re-simplify the binding (and the Simplifier does
745 sometimes simplify a term twice); see Trac #4345.
746
747 It's not so simple to retain
748   * worker info
749   * rules
750 so we simply discard those.  Sooner or later this may bite us.
751
752 If we abstract wrt one or more *value* binders, we must modify the
753 arity and strictness info before transferring it.  E.g.
754       f = \x. e
755 -->
756       g' = \y. \x. e
757       + substitute (g' y) for g
758 Notice that g' has an arity one more than the original g
759
760 \begin{code}
761 transferPolyIdInfo :: Id        -- Original Id
762                    -> [Var]     -- Abstract wrt these variables
763                    -> Id        -- New Id
764                    -> Id
765 transferPolyIdInfo old_id abstract_wrt new_id
766   = modifyIdInfo transfer new_id
767   where
768     arity_increase = count isId abstract_wrt    -- Arity increases by the
769                                                 -- number of value binders
770
771     old_info        = idInfo old_id
772     old_arity       = arityInfo old_info
773     old_inline_prag = inlinePragInfo old_info
774     old_occ_info    = occInfo old_info
775     new_arity       = old_arity + arity_increase
776
777     old_strictness  = strictnessInfo old_info
778     new_strictness  = increaseStrictSigArity arity_increase old_strictness
779
780     transfer new_info = new_info `setArityInfo` new_arity
781                                  `setInlinePragInfo` old_inline_prag
782                                  `setOccInfo` old_occ_info
783                                  `setStrictnessInfo` new_strictness
784 \end{code}