2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
4 \section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
6 (And a pretty good illustration of quite a few things wrong with
11 GlobalIdDetails(..), notGlobalId, -- Not abstract
14 vanillaIdInfo, noCafNoTyGenIdInfo,
15 seqIdInfo, megaSeqIdInfo,
18 zapLamInfo, zapDemandInfo,
19 shortableIdInfo, copyIdInfo,
23 exactArity, unknownArity, hasArity,
24 arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
26 -- New demand and strictness info
27 newStrictnessInfo, setNewStrictnessInfo, mkNewStrictnessInfo,
28 newDemandInfo, setNewDemandInfo, newDemand, oldDemand,
30 -- Strictness; imported from Demand
32 mkStrictnessInfo, noStrictnessInfo,
33 ppStrictnessInfo,isBottomingStrictness,
34 strictnessInfo, setStrictnessInfo,
36 -- Usage generalisation
38 tyGenInfo, setTyGenInfo,
39 noTyGenInfo, isNoTyGenInfo, ppTyGenInfo, tyGenInfoString,
42 WorkerInfo(..), workerExists, wrapperArity, workerId,
43 workerInfo, setWorkerInfo, ppWorkerInfo,
46 unfoldingInfo, setUnfoldingInfo,
49 demandInfo, setDemandInfo,
53 inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
54 isNeverInlinePrag, neverInlinePrag,
57 OccInfo(..), isFragileOcc, isDeadOcc, isLoopBreaker,
58 InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
62 specInfo, setSpecInfo,
65 CgInfo(..), cgInfo, setCgInfo, cgMayHaveCafRefs, pprCgInfo,
66 cgArity, cgCafInfo, vanillaCgInfo,
67 CgInfoEnv, lookupCgInfo,
71 CafInfo(..), ppCafInfo, setCafInfo, mayHaveCafRefs,
73 -- Constructed Product Result Info
74 CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
76 -- Lambda-bound variable info
77 LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
80 #include "HsVersions.h"
84 import Type ( Type, usOnce, eqUsage )
85 import PrimOp ( PrimOp )
86 import NameEnv ( NameEnv, lookupNameEnv )
89 import BasicTypes ( OccInfo(..), isFragileOcc, isDeadOcc, seqOccInfo, isLoopBreaker,
90 InsideLam, insideLam, notInsideLam,
91 OneBranch, oneBranch, notOneBranch,
94 import DataCon ( DataCon )
95 import ForeignCall ( ForeignCall )
96 import FieldLabel ( FieldLabel )
97 import Type ( usOnce, usMany )
98 import Demand hiding( Demand )
99 import NewDemand ( Demand(..), Keepity(..), Deferredness(..), DmdResult(..),
101 StrictSig, mkStrictSig,
102 DmdType, mkTopDmdType
105 import Util ( seqList )
106 import List ( replicate )
108 infixl 1 `setDemandInfo`,
122 `setNewStrictnessInfo`,
124 -- infixl so you can say (id `set` a `set` b)
127 %************************************************************************
129 \subsection{New strictness info}
131 %************************************************************************
136 mkNewStrictnessInfo :: Id -> Arity -> Demand.StrictnessInfo -> CprInfo -> StrictSig
137 mkNewStrictnessInfo id arity Demand.NoStrictnessInfo cpr
138 = mkStrictSig id arity $
139 mkTopDmdType (replicate arity lazyDmd) (newRes False cpr)
141 mkNewStrictnessInfo id arity (Demand.StrictnessInfo ds res) cpr
142 = mkStrictSig id arity $
143 mkTopDmdType (take arity (map newDemand ds)) (newRes res cpr)
144 -- Sometimes the old strictness analyser has more
145 -- demands than the arity justifies
147 newRes True _ = BotRes
148 newRes False ReturnsCPR = RetCPR
149 newRes False NoCPRInfo = TopRes
151 newDemand :: Demand.Demand -> NewDemand.Demand
152 newDemand (WwLazy True) = Abs
153 newDemand (WwLazy False) = Lazy
154 newDemand WwStrict = Eval
155 newDemand (WwUnpack unpk ds) = Seq Drop Now (map newDemand ds)
156 newDemand WwPrim = Lazy
157 newDemand WwEnum = Eval
159 oldDemand :: NewDemand.Demand -> Demand.Demand
160 oldDemand Abs = WwLazy True
161 oldDemand Lazy = WwLazy False
162 oldDemand Eval = WwStrict
163 oldDemand (Seq _ _ ds) = WwUnpack True (map oldDemand ds)
164 oldDemand (Call _) = WwStrict
168 %************************************************************************
170 \subsection{GlobalIdDetails
172 %************************************************************************
174 This type is here (rather than in Id.lhs) mainly because there's
175 an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
176 (recursively) by Var.lhs.
180 = VanillaGlobal -- Imported from elsewhere, a default method Id.
182 | RecordSelId FieldLabel -- The Id for a record selector
183 | DataConId DataCon -- The Id for a data constructor *worker*
184 | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
185 -- [the only reasons we need to know is so that
186 -- a) we can suppress printing a definition in the interface file
187 -- b) when typechecking a pattern we can get from the
188 -- Id back to the data con]
190 | PrimOpId PrimOp -- The Id for a primitive operator
191 | FCallId ForeignCall -- The Id for a foreign call
193 | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
195 notGlobalId = NotGlobalId
197 instance Outputable GlobalIdDetails where
198 ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
199 ppr VanillaGlobal = ptext SLIT("[GlobalId]")
200 ppr (DataConId _) = ptext SLIT("[DataCon]")
201 ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
202 ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
203 ppr (FCallId _) = ptext SLIT("[ForeignCall]")
204 ppr (RecordSelId _) = ptext SLIT("[RecSel]")
208 %************************************************************************
210 \subsection{The main IdInfo type}
212 %************************************************************************
214 An @IdInfo@ gives {\em optional} information about an @Id@. If
215 present it never lies, but it may not be present, in which case there
216 is always a conservative assumption which can be made.
218 Two @Id@s may have different info even though they have the same
219 @Unique@ (and are hence the same @Id@); for example, one might lack
220 the properties attached to the other.
222 The @IdInfo@ gives information about the value, or definition, of the
223 @Id@. It does {\em not} contain information about the @Id@'s usage
224 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
230 arityInfo :: ArityInfo, -- Its arity
231 demandInfo :: Demand.Demand, -- Whether or not it is definitely demanded
232 specInfo :: CoreRules, -- Specialisations of this function which exist
233 tyGenInfo :: TyGenInfo, -- Restrictions on usage-generalisation of this Id
234 strictnessInfo :: StrictnessInfo, -- Strictness properties
235 workerInfo :: WorkerInfo, -- Pointer to Worker Function
236 unfoldingInfo :: Unfolding, -- Its unfolding
237 cgInfo :: CgInfo, -- Code generator info (arity, CAF info)
238 cprInfo :: CprInfo, -- Function always constructs a product result
239 lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
240 inlinePragInfo :: InlinePragInfo, -- Inline pragma
241 occInfo :: OccInfo, -- How it occurs
243 newStrictnessInfo :: Maybe StrictSig,
244 newDemandInfo :: Demand
247 seqIdInfo :: IdInfo -> ()
248 seqIdInfo (IdInfo {}) = ()
250 megaSeqIdInfo :: IdInfo -> ()
252 = seqArity (arityInfo info) `seq`
253 seqDemand (demandInfo info) `seq`
254 seqRules (specInfo info) `seq`
255 seqTyGenInfo (tyGenInfo info) `seq`
256 seqStrictnessInfo (strictnessInfo info) `seq`
257 seqWorker (workerInfo info) `seq`
259 -- seqUnfolding (unfoldingInfo info) `seq`
260 -- Omitting this improves runtimes a little, presumably because
261 -- some unfoldings are not calculated at all
263 -- CgInfo is involved in a loop, so we have to be careful not to seq it
265 -- seqCg (cgInfo info) `seq`
266 seqCpr (cprInfo info) `seq`
267 seqLBVar (lbvarInfo info) `seq`
268 seqOccInfo (occInfo info)
274 setWorkerInfo info wk = wk `seq` info { workerInfo = wk }
275 setSpecInfo info sp = PSEQ sp (info { specInfo = sp })
276 setTyGenInfo info tg = tg `seq` info { tyGenInfo = tg }
277 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
278 setOccInfo info oc = oc `seq` info { occInfo = oc }
279 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
280 -- Try to avoid spack leaks by seq'ing
282 setUnfoldingInfo info uf
283 | isEvaldUnfolding uf && isStrict (demandInfo info)
284 -- If the unfolding is a value, the demand info may
285 -- go pear-shaped, so we nuke it. Example:
287 -- case x of (p,q) -> h p q x
288 -- Here x is certainly demanded. But after we've nuked
289 -- the case, we'll get just
290 -- let x = (a,b) in h a b x
291 -- and now x is not demanded (I'm assuming h is lazy)
292 -- This really happens. The solution here is a bit ad hoc...
293 = info { unfoldingInfo = uf, demandInfo = wwLazy }
296 -- We do *not* seq on the unfolding info, For some reason, doing so
297 -- actually increases residency significantly.
298 = info { unfoldingInfo = uf }
300 setDemandInfo info dd = info { demandInfo = dd }
301 setArityInfo info ar = info { arityInfo = Just ar }
302 setCgInfo info cg = info { cgInfo = cg }
303 setCprInfo info cp = info { cprInfo = cp }
304 setLBVarInfo info lb = info { lbvarInfo = lb }
306 setNewDemandInfo info dd = info { newDemandInfo = dd }
307 setNewStrictnessInfo info dd = info { newStrictnessInfo = dd }
312 vanillaIdInfo :: IdInfo
316 arityInfo = unknownArity,
318 specInfo = emptyCoreRules,
319 tyGenInfo = noTyGenInfo,
320 workerInfo = NoWorker,
321 strictnessInfo = NoStrictnessInfo,
322 unfoldingInfo = noUnfolding,
324 lbvarInfo = NoLBVarInfo,
325 inlinePragInfo = NoInlinePragInfo,
327 newDemandInfo = topDmd,
328 newStrictnessInfo = Nothing
331 noCafNoTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
332 `setCgInfo` (CgInfo 0 NoCafRefs)
333 -- Used for built-in type Ids in MkId.
334 -- Many built-in things have fixed types, so we shouldn't
335 -- run around generalising them
339 %************************************************************************
341 \subsection[arity-IdInfo]{Arity info about an @Id@}
343 %************************************************************************
345 For locally-defined Ids, the code generator maintains its own notion
346 of their arities; so it should not be asking... (but other things
347 besides the code-generator need arity info!)
350 type ArityInfo = Maybe Arity
351 -- A partial application of this Id to up to n-1 value arguments
352 -- does essentially no work. That is not necessarily the
353 -- same as saying that it has n leading lambdas, because coerces
354 -- may get in the way.
356 -- The arity might increase later in the compilation process, if
357 -- an extra lambda floats up to the binding site.
359 seqArity :: ArityInfo -> ()
360 seqArity a = arityLowerBound a `seq` ()
363 unknownArity = Nothing
365 arityLowerBound :: ArityInfo -> Arity
366 arityLowerBound Nothing = 0
367 arityLowerBound (Just n) = n
369 hasArity :: ArityInfo -> Bool
370 hasArity Nothing = False
371 hasArity other = True
373 ppArityInfo Nothing = empty
374 ppArityInfo (Just arity) = hsep [ptext SLIT("Arity"), int arity]
377 %************************************************************************
379 \subsection{Inline-pragma information}
381 %************************************************************************
386 | IMustNotBeINLINEd Bool -- True <=> came from an INLINE prag, False <=> came from a NOINLINE prag
387 (Maybe Int) -- Phase number from pragma, if any
389 -- The True, Nothing case doesn't need to be recorded
391 -- SEE COMMENTS WITH CoreUnfold.blackListed on the
392 -- exact significance of the IMustNotBeINLINEd pragma
394 isNeverInlinePrag :: InlinePragInfo -> Bool
395 isNeverInlinePrag (IMustNotBeINLINEd _ Nothing) = True
396 isNeverInlinePrag other = False
398 neverInlinePrag :: InlinePragInfo
399 neverInlinePrag = IMustNotBeINLINEd True{-should be False? --SDM -} Nothing
401 instance Outputable InlinePragInfo where
402 -- This is now parsed in interface files
403 ppr NoInlinePragInfo = empty
404 ppr other_prag = ptext SLIT("__U") <> pprInlinePragInfo other_prag
406 pprInlinePragInfo NoInlinePragInfo = empty
407 pprInlinePragInfo (IMustNotBeINLINEd True Nothing) = empty
408 pprInlinePragInfo (IMustNotBeINLINEd True (Just n)) = brackets (int n)
409 pprInlinePragInfo (IMustNotBeINLINEd False Nothing) = brackets (char '!')
410 pprInlinePragInfo (IMustNotBeINLINEd False (Just n)) = brackets (char '!' <> int n)
412 instance Show InlinePragInfo where
413 showsPrec p prag = showsPrecSDoc p (ppr prag)
417 %************************************************************************
419 \subsection[TyGen-IdInfo]{Type generalisation info about an @Id@}
421 %************************************************************************
423 Certain passes (notably usage inference) may change the type of an
424 identifier, modifying all in-scope uses of that identifier
425 appropriately to maintain type safety.
427 However, some identifiers must not have their types changed in this
428 way, because their types are conjured up in the front end of the
429 compiler rather than being read from the interface file. Default
430 methods, dictionary functions, record selectors, and others are in
431 this category. (see comment at TcClassDcl.tcClassSig).
433 To indicate this property, such identifiers are marked TyGenNever.
435 Furthermore, if the usage inference generates a usage-specialised
436 variant of a function, we must NOT re-infer a fully-generalised type
437 at the next inference. This finer property is indicated by a
438 TyGenUInfo on the identifier.
442 = NoTyGenInfo -- no restriction on type generalisation
444 | TyGenUInfo [Maybe Type] -- restrict generalisation of this Id to
445 -- preserve specified usage annotations
447 | TyGenNever -- never generalise the type of this Id
450 For TyGenUInfo, the list has one entry for each usage annotation on
451 the type of the Id, in left-to-right pre-order (annotations come
452 before the type they annotate). Nothing means no restriction; Just
453 usOnce or Just usMany forces that annotation to that value. Other
454 usage annotations are illegal.
457 seqTyGenInfo :: TyGenInfo -> ()
458 seqTyGenInfo NoTyGenInfo = ()
459 seqTyGenInfo (TyGenUInfo us) = seqList us ()
460 seqTyGenInfo TyGenNever = ()
462 noTyGenInfo :: TyGenInfo
463 noTyGenInfo = NoTyGenInfo
465 isNoTyGenInfo :: TyGenInfo -> Bool
466 isNoTyGenInfo NoTyGenInfo = True
467 isNoTyGenInfo _ = False
469 -- NB: There's probably no need to write this information out to the interface file.
470 -- Why? Simply because imported identifiers never get their types re-inferred.
471 -- But it's definitely nice to see in dumps, it for debugging purposes.
473 ppTyGenInfo :: TyGenInfo -> SDoc
474 ppTyGenInfo NoTyGenInfo = empty
475 ppTyGenInfo (TyGenUInfo us) = ptext SLIT("__G") <+> text (tyGenInfoString us)
476 ppTyGenInfo TyGenNever = ptext SLIT("__G N")
478 tyGenInfoString us = map go us
479 where go Nothing = 'x' -- for legibility, choose
480 go (Just u) | u `eqUsage` usOnce = '1' -- chars with identity
481 | u `eqUsage` usMany = 'M' -- Z-encoding.
482 go other = pprPanic "IdInfo.tyGenInfoString: unexpected annotation" (ppr other)
484 instance Outputable TyGenInfo where
487 instance Show TyGenInfo where
488 showsPrec p c = showsPrecSDoc p (ppr c)
492 %************************************************************************
494 \subsection[worker-IdInfo]{Worker info about an @Id@}
496 %************************************************************************
498 If this Id has a worker then we store a reference to it. Worker
499 functions are generated by the worker/wrapper pass. This uses
500 information from the strictness and CPR analyses.
502 There might not be a worker, even for a strict function, because:
503 (a) the function might be small enough to inline, so no need
505 (b) the strictness info might be "SSS" or something, so no w/w split.
507 Sometimes the arity of a wrapper changes from the original arity from
508 which it was generated, so we always emit the "original" arity into
509 the interface file, as part of the worker info.
511 How can this happen? Sometimes we get
512 f = coerce t (\x y -> $wf x y)
513 at the moment of w/w split; but the eta reducer turns it into
515 which is perfectly fine except that the exposed arity so far as
516 the code generator is concerned (zero) differs from the arity
517 when we did the split (2).
519 All this arises because we use 'arity' to mean "exactly how many
520 top level lambdas are there" in interface files; but during the
521 compilation of this module it means "how many things can I apply
526 data WorkerInfo = NoWorker
528 -- The Arity is the arity of the *wrapper* at the moment of the
529 -- w/w split. See comments in MkIface.ifaceId, with the 'Worker' code.
531 seqWorker :: WorkerInfo -> ()
532 seqWorker (HasWorker id _) = id `seq` ()
533 seqWorker NoWorker = ()
535 ppWorkerInfo NoWorker = empty
536 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
538 workerExists :: WorkerInfo -> Bool
539 workerExists NoWorker = False
540 workerExists (HasWorker _ _) = True
542 workerId :: WorkerInfo -> Id
543 workerId (HasWorker id _) = id
545 wrapperArity :: WorkerInfo -> Arity
546 wrapperArity (HasWorker _ a) = a
550 %************************************************************************
552 \subsection[CG-IdInfo]{Code generator-related information}
554 %************************************************************************
556 CgInfo encapsulates calling-convention information produced by the code
557 generator. It is pasted into the IdInfo of each emitted Id by CoreTidy,
558 but only as a thunk --- the information is only actually produced further
559 downstream, by the code generator.
563 !Arity -- Exact arity for calling purposes
566 | NoCgInfo -- In debug mode we don't want a black hole here
569 -- noCgInfo is used for local Ids, which shouldn't need any CgInfo
572 noCgInfo = panic "NoCgInfo!"
575 cgArity (CgInfo arity _) = arity
576 cgCafInfo (CgInfo _ caf_info) = caf_info
578 setCafInfo info caf_info =
579 case cgInfo info of { CgInfo arity _ ->
580 info `setCgInfo` CgInfo arity caf_info }
582 setCgArity info arity =
583 case cgInfo info of { CgInfo _ caf_info ->
584 info `setCgInfo` CgInfo arity caf_info }
586 cgMayHaveCafRefs (CgInfo _ caf_info) = mayHaveCafRefs caf_info
588 seqCg c = c `seq` () -- fields are strict anyhow
590 vanillaCgInfo = CgInfo 0 MayHaveCafRefs -- Definitely safe
592 -- CafInfo is used to build Static Reference Tables (see simplStg/SRT.lhs).
595 = MayHaveCafRefs -- either:
596 -- (1) A function or static constructor
597 -- that refers to one or more CAFs,
598 -- (2) A real live CAF
600 | NoCafRefs -- A function or static constructor
601 -- that refers to no CAFs.
603 mayHaveCafRefs MayHaveCafRefs = True
604 mayHaveCafRefs _ = False
606 seqCaf c = c `seq` ()
608 pprCgInfo (CgInfo arity caf_info) = ppArity arity <+> ppCafInfo caf_info
611 ppArity n = hsep [ptext SLIT("__A"), int n]
613 ppCafInfo NoCafRefs = ptext SLIT("__C")
614 ppCafInfo MayHaveCafRefs = empty
618 type CgInfoEnv = NameEnv CgInfo
620 lookupCgInfo :: NameEnv CgInfo -> Name -> CgInfo
621 lookupCgInfo env n = case lookupNameEnv env n of
623 Nothing -> pprTrace "Urk! Not in CgInfo env" (ppr n) vanillaCgInfo
627 %************************************************************************
629 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
631 %************************************************************************
633 If the @Id@ is a function then it may have CPR info. A CPR analysis
634 phase detects whether:
638 The function's return value has a product type, i.e. an algebraic type
639 with a single constructor. Examples of such types are tuples and boxed
642 The function always 'constructs' the value that it is returning. It
643 must do this on every path through, and it's OK if it calls another
644 function which constructs the result.
647 If this is the case then we store a template which tells us the
648 function has the CPR property and which components of the result are
654 | ReturnsCPR -- Yes, this function returns a constructed product
655 -- Implicitly, this means "after the function has been applied
656 -- to all its arguments", so the worker/wrapper builder in
657 -- WwLib.mkWWcpr checks that that it is indeed saturated before
658 -- making use of the CPR info
660 -- We used to keep nested info about sub-components, but
661 -- we never used it so I threw it away
665 seqCpr :: CprInfo -> ()
666 seqCpr ReturnsCPR = ()
667 seqCpr NoCPRInfo = ()
669 noCprInfo = NoCPRInfo
671 ppCprInfo NoCPRInfo = empty
672 ppCprInfo ReturnsCPR = ptext SLIT("__M")
674 instance Outputable CprInfo where
677 instance Show CprInfo where
678 showsPrec p c = showsPrecSDoc p (ppr c)
682 %************************************************************************
684 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
686 %************************************************************************
688 If the @Id@ is a lambda-bound variable then it may have lambda-bound
689 var info. The usage analysis (UsageSP) detects whether the lambda
690 binding this var is a ``one-shot'' lambda; that is, whether it is
691 applied at most once.
693 This information may be useful in optimisation, as computations may
694 safely be floated inside such a lambda without risk of duplicating
701 | LBVarInfo Type -- The lambda that binds this Id has this usage
702 -- annotation (i.e., if ==usOnce, then the
703 -- lambda is applied at most once).
704 -- The annotation's kind must be `$'
705 -- HACK ALERT! placing this info here is a short-term hack,
706 -- but it minimises changes to the rest of the compiler.
707 -- Hack agreed by SLPJ/KSW 1999-04.
709 seqLBVar l = l `seq` ()
713 hasNoLBVarInfo NoLBVarInfo = True
714 hasNoLBVarInfo other = False
716 noLBVarInfo = NoLBVarInfo
718 -- not safe to print or parse LBVarInfo because it is not really a
719 -- property of the definition, but a property of the context.
720 pprLBVarInfo NoLBVarInfo = empty
721 pprLBVarInfo (LBVarInfo u) | u `eqUsage` usOnce
722 = getPprStyle $ \ sty ->
725 else ptext SLIT("OneShot")
729 instance Outputable LBVarInfo where
732 instance Show LBVarInfo where
733 showsPrec p c = showsPrecSDoc p (ppr c)
737 %************************************************************************
739 \subsection{Bulk operations on IdInfo}
741 %************************************************************************
743 @zapLamInfo@ is used for lambda binders that turn out to to be
744 part of an unsaturated lambda
747 zapLamInfo :: IdInfo -> Maybe IdInfo
748 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
749 | is_safe_occ && not (isStrict demand)
752 = Just (info {occInfo = safe_occ,
753 demandInfo = wwLazy})
755 -- The "unsafe" occ info is the ones that say I'm not in a lambda
756 -- because that might not be true for an unsaturated lambda
757 is_safe_occ = case occ of
758 OneOcc in_lam once -> in_lam
761 safe_occ = case occ of
762 OneOcc _ once -> OneOcc insideLam once
767 zapDemandInfo :: IdInfo -> Maybe IdInfo
768 zapDemandInfo info@(IdInfo {demandInfo = demand})
769 | not (isStrict demand) = Nothing
770 | otherwise = Just (info {demandInfo = wwLazy})
774 copyIdInfo is used when shorting out a top-level binding
777 where f is exported. We are going to swizzle it around to
781 BUT (a) we must be careful about messing up rules
782 (b) we must ensure f's IdInfo ends up right
784 (a) Messing up the rules
786 The example that went bad on me was this one:
788 iterate :: (a -> a) -> a -> [a]
789 iterate = iterateList
791 iterateFB c f x = x `c` iterateFB c f (f x)
792 iterateList f x = x : iterateList f (f x)
795 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
796 "iterateFB" iterateFB (:) = iterateList
799 This got shorted out to:
801 iterateList :: (a -> a) -> a -> [a]
802 iterateList = iterate
804 iterateFB c f x = x `c` iterateFB c f (f x)
805 iterate f x = x : iterate f (f x)
808 "iterate" forall f x. iterate f x = build (\c _n -> iterateFB c f x)
809 "iterateFB" iterateFB (:) = iterate
812 And now we get an infinite loop in the rule system
813 iterate f x -> build (\cn -> iterateFB c f x)
817 Tiresome solution: don't do shorting out if f has rewrite rules.
818 Hence shortableIdInfo.
820 (b) Keeping the IdInfo right
821 ~~~~~~~~~~~~~~~~~~~~~~~~
822 We want to move strictness/worker info from f_local to f, but keep the rest.
826 shortableIdInfo :: IdInfo -> Bool
827 shortableIdInfo info = isEmptyCoreRules (specInfo info)
829 copyIdInfo :: IdInfo -- f_local
830 -> IdInfo -- f (the exported one)
831 -> IdInfo -- New info for f
832 copyIdInfo f_local f = f { strictnessInfo = strictnessInfo f_local,
833 workerInfo = workerInfo f_local,
834 cprInfo = cprInfo f_local