ghc/compiler/basicTypes/IdInfo.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1993-1998
   3 %
   4 \section[IdInfo]{@IdInfos@: Non-essential information about @Ids@}
   5
   6 (And a pretty good illustration of quite a few things wrong with
   7 Haskell. [WDP 94/11])
   8
   9 \begin{code}
  10 module IdInfo (
  11         IdInfo,         -- Abstract
  12
  13         vanillaIdInfo, mkIdInfo, seqIdInfo, megaSeqIdInfo,
  14
  15         -- Zapping
  16         zapFragileInfo, zapLamInfo, zapSpecPragInfo, copyIdInfo,
  17
  18         -- Flavour
  19         IdFlavour(..), flavourInfo,
  20         setNoDiscardInfo,
  21         ppFlavourInfo,
  22
  23         -- Arity
  24         ArityInfo(..),
  25         exactArity, atLeastArity, unknownArity, hasArity,
  26         arityInfo, setArityInfo, ppArityInfo, arityLowerBound,
  27
  28         -- Strictness; imported from Demand
  29         StrictnessInfo(..),
  30         mkStrictnessInfo, noStrictnessInfo,
  31         ppStrictnessInfo,isBottomingStrictness,
  32
  33         strictnessInfo, setStrictnessInfo,
  34
  35         -- Worker
  36         WorkerInfo(..), workerExists, wrapperArity, workerId,
  37         workerInfo, setWorkerInfo, ppWorkerInfo,
  38
  39         -- Unfolding
  40         unfoldingInfo, setUnfoldingInfo,
  41
  42         -- DemandInfo
  43         demandInfo, setDemandInfo,
  44
  45         -- Inline prags
  46         InlinePragInfo(..),
  47         inlinePragInfo, setInlinePragInfo, pprInlinePragInfo,
  48         isNeverInlinePrag, neverInlinePrag,
  49
  50         -- Occurrence info
  51         OccInfo(..), isFragileOccInfo,
  52         InsideLam, OneBranch, insideLam, notInsideLam, oneBranch, notOneBranch,
  53         occInfo, setOccInfo,
  54
  55         -- Specialisation
  56         specInfo, setSpecInfo,
  57
  58         -- Update
  59         UpdateInfo, UpdateSpec,
  60         mkUpdateInfo, updateInfo, updateInfoMaybe, ppUpdateInfo, setUpdateInfo,
  61
  62         -- CAF info
  63         CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
  64
  65         -- Constructed Product Result Info
  66         CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
  67
  68         -- Lambda-bound variable info
  69         LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo
  70     ) where
  71
  72 #include "HsVersions.h"
  73
  74
  75 import CoreSyn
  76 import PrimOp           ( PrimOp )
  77 import Var              ( Id )
  78 import BasicTypes       ( OccInfo(..), isFragileOccInfo, seqOccInfo,
  79                           InsideLam, insideLam, notInsideLam,
  80                           OneBranch, oneBranch, notOneBranch,
  81                           Arity
  82                         )
  83 import DataCon          ( DataCon )
  84 import FieldLabel       ( FieldLabel )
  85 import Demand           -- Lots of stuff
  86 import Outputable
  87 import Maybe            ( isJust )
  88
  89 infixl  1 `setUpdateInfo`,
  90           `setDemandInfo`,
  91           `setStrictnessInfo`,
  92           `setSpecInfo`,
  93           `setArityInfo`,
  94           `setInlinePragInfo`,
  95           `setUnfoldingInfo`,
  96           `setCprInfo`,
  97           `setWorkerInfo`,
  98           `setCafInfo`,
  99           `setOccInfo`
 100         -- infixl so you can say (id `set` a `set` b)
 101 \end{code}
 102
 103 An @IdInfo@ gives {\em optional} information about an @Id@.  If
 104 present it never lies, but it may not be present, in which case there
 105 is always a conservative assumption which can be made.
 106
 107         There is one exception: the 'flavour' is *not* optional.
 108         You must not discard it.
 109         It used to be in Var.lhs, but that seems unclean.
 110
 111 Two @Id@s may have different info even though they have the same
 112 @Unique@ (and are hence the same @Id@); for example, one might lack
 113 the properties attached to the other.
 114
 115 The @IdInfo@ gives information about the value, or definition, of the
 116 @Id@.  It does {\em not} contain information about the @Id@'s usage
 117 (except for @DemandInfo@? ToDo). (@lbvarInfo@ is also a marginal
 118 case.  KSW 1999-04).
 119
 120 \begin{code}
 121 data IdInfo
 122   = IdInfo {
 123         flavourInfo     :: IdFlavour,           -- NOT OPTIONAL
 124         arityInfo       :: ArityInfo,           -- Its arity
 125         demandInfo      :: Demand,              -- Whether or not it is definitely demanded
 126         specInfo        :: CoreRules,           -- Specialisations of this function which exist
 127         strictnessInfo  :: StrictnessInfo,      -- Strictness properties
 128         workerInfo      :: WorkerInfo,          -- Pointer to Worker Function
 129         unfoldingInfo   :: Unfolding,           -- Its unfolding
 130         updateInfo      :: UpdateInfo,          -- Which args should be updated
 131         cafInfo         :: CafInfo,
 132         cprInfo         :: CprInfo,             -- Function always constructs a product result
 133         lbvarInfo       :: LBVarInfo,           -- Info about a lambda-bound variable
 134         inlinePragInfo  :: InlinePragInfo,      -- Inline pragma
 135         occInfo         :: OccInfo              -- How it occurs
 136     }
 137
 138 seqIdInfo :: IdInfo -> ()
 139 seqIdInfo (IdInfo {}) = ()
 140
 141 megaSeqIdInfo :: IdInfo -> ()
 142 megaSeqIdInfo info
 143   = seqFlavour (flavourInfo info)               `seq`
 144     seqArity (arityInfo info)                   `seq`
 145     seqDemand (demandInfo info)                 `seq`
 146     seqRules (specInfo info)                    `seq`
 147     seqStrictnessInfo (strictnessInfo info)     `seq`
 148     seqWorker (workerInfo info)                 `seq`
 149
 150 --    seqUnfolding (unfoldingInfo info) `seq`
 151 -- Omitting this improves runtimes a little, presumably because
 152 -- some unfoldings are not calculated at all
 153
 154     seqCaf (cafInfo info)               `seq`
 155     seqCpr (cprInfo info)               `seq`
 156     seqLBVar (lbvarInfo info)           `seq`
 157     seqOccInfo (occInfo info)
 158 \end{code}
 159
 160 Setters
 161
 162 \begin{code}
 163 setWorkerInfo     info wk = wk `seq` info { workerInfo = wk }
 164 setSpecInfo       info sp = PSEQ sp (info { specInfo = sp })
 165 setInlinePragInfo info pr = pr `seq` info { inlinePragInfo = pr }
 166 setOccInfo        info oc = oc `seq` info { occInfo = oc }
 167 setStrictnessInfo info st = st `seq` info { strictnessInfo = st }
 168         -- Try to avoid spack leaks by seq'ing
 169
 170 setUnfoldingInfo  info uf
 171   | isEvaldUnfolding uf && isStrict (demandInfo info)
 172         -- If the unfolding is a value, the demand info may
 173         -- go pear-shaped, so we nuke it.  Example:
 174         --      let x = (a,b) in
 175         --      case x of (p,q) -> h p q x
 176         -- Here x is certainly demanded. But after we've nuked
 177         -- the case, we'll get just
 178         --      let x = (a,b) in h a b x
 179         -- and now x is not demanded (I'm assuming h is lazy)
 180         -- This really happens.  The solution here is a bit ad hoc...
 181   = info { unfoldingInfo = uf, demandInfo = wwLazy }
 182
 183   | otherwise
 184         -- We do *not* seq on the unfolding info, For some reason, doing so
 185         -- actually increases residency significantly.
 186   = info { unfoldingInfo = uf }
 187
 188 setUpdateInfo     info ud = info { updateInfo = ud }
 189 setDemandInfo     info dd = info { demandInfo = dd }
 190 setArityInfo      info ar = info { arityInfo = ar  }
 191 setCafInfo        info cf = info { cafInfo = cf }
 192 setCprInfo        info cp = info { cprInfo = cp }
 193 setLBVarInfo      info lb = info { lbvarInfo = lb }
 194
 195 setNoDiscardInfo  info = case flavourInfo info of
 196                                 VanillaId -> info { flavourInfo = NoDiscardId }
 197                                 other     -> info
 198 zapSpecPragInfo   info = case flavourInfo info of
 199                                 SpecPragmaId -> info { flavourInfo = VanillaId }
 200                                 other        -> info
 201 \end{code}
 202
 203
 204 \begin{code}
 205 vanillaIdInfo :: IdInfo
 206 vanillaIdInfo = mkIdInfo VanillaId
 207
 208 mkIdInfo :: IdFlavour -> IdInfo
 209 mkIdInfo flv = IdInfo {
 210                     flavourInfo         = flv,
 211                     arityInfo           = UnknownArity,
 212                     demandInfo          = wwLazy,
 213                     specInfo            = emptyCoreRules,
 214                     workerInfo          = NoWorker,
 215                     strictnessInfo      = NoStrictnessInfo,
 216                     unfoldingInfo       = noUnfolding,
 217                     updateInfo          = NoUpdateInfo,
 218                     cafInfo             = MayHaveCafRefs,
 219                     cprInfo             = NoCPRInfo,
 220                     lbvarInfo           = NoLBVarInfo,
 221                     inlinePragInfo      = NoInlinePragInfo,
 222                     occInfo             = NoOccInfo
 223            }
 224 \end{code}
 225
 226
 227 %************************************************************************
 228 %*                                                                      *
 229 \subsection{Flavour}
 230 %*                                                                      *
 231 %************************************************************************
 232
 233 \begin{code}
 234 data IdFlavour
 235   = VanillaId                   -- Most Ids are like this
 236   | DataConId DataCon           -- The Id for a data constructor *worker*
 237   | DataConWrapId DataCon       -- The Id for a data constructor *wrapper*
 238                                 -- [the only reasons we need to know is so that
 239                                 --  a) we can  suppress printing a definition in the interface file
 240                                 --  b) when typechecking a pattern we can get from the
 241                                 --     Id back to the data con]
 242   | PrimOpId PrimOp             -- The Id for a primitive operator
 243   | RecordSelId FieldLabel      -- The Id for a record selector
 244   | SpecPragmaId                -- Don't discard these
 245   | NoDiscardId                 -- Don't discard these either
 246
 247 ppFlavourInfo :: IdFlavour -> SDoc
 248 ppFlavourInfo VanillaId         = empty
 249 ppFlavourInfo (DataConId _)     = ptext SLIT("[DataCon]")
 250 ppFlavourInfo (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
 251 ppFlavourInfo (PrimOpId _)      = ptext SLIT("[PrimOp]")
 252 ppFlavourInfo (RecordSelId _)   = ptext SLIT("[RecSel]")
 253 ppFlavourInfo SpecPragmaId      = ptext SLIT("[SpecPrag]")
 254 ppFlavourInfo NoDiscardId       = ptext SLIT("[NoDiscard]")
 255
 256 seqFlavour :: IdFlavour -> ()
 257 seqFlavour f = f `seq` ()
 258 \end{code}
 259
 260 The @SpecPragmaId@ exists only to make Ids that are
 261 on the *LHS* of bindings created by SPECIALISE pragmas;
 262 eg:             s = f Int d
 263 The SpecPragmaId is never itself mentioned; it
 264 exists solely so that the specialiser will find
 265 the call to f, and make specialised version of it.
 266 The SpecPragmaId binding is discarded by the specialiser
 267 when it gathers up overloaded calls.
 268 Meanwhile, it is not discarded as dead code.
 269
 270
 271 %************************************************************************
 272 %*                                                                      *
 273 \subsection[arity-IdInfo]{Arity info about an @Id@}
 274 %*                                                                      *
 275 %************************************************************************
 276
 277 For locally-defined Ids, the code generator maintains its own notion
 278 of their arities; so it should not be asking...  (but other things
 279 besides the code-generator need arity info!)
 280
 281 \begin{code}
 282 data ArityInfo
 283   = UnknownArity        -- No idea
 284
 285   | ArityExactly Arity  -- Arity is exactly this.  We use this when importing a
 286                         -- function; it's already been compiled and we know its
 287                         -- arity for sure.
 288
 289   | ArityAtLeast Arity  -- Arity is this or greater.  We attach this arity to
 290                         -- functions in the module being compiled.  Their arity
 291                         -- might increase later in the compilation process, if
 292                         -- an extra lambda floats up to the binding site.
 293
 294 seqArity :: ArityInfo -> ()
 295 seqArity a = arityLowerBound a `seq` ()
 296
 297 exactArity   = ArityExactly
 298 atLeastArity = ArityAtLeast
 299 unknownArity = UnknownArity
 300
 301 arityLowerBound :: ArityInfo -> Arity
 302 arityLowerBound UnknownArity     = 0
 303 arityLowerBound (ArityAtLeast n) = n
 304 arityLowerBound (ArityExactly n) = n
 305
 306 hasArity :: ArityInfo -> Bool
 307 hasArity UnknownArity = False
 308 hasArity other        = True
 309
 310 ppArityInfo UnknownArity         = empty
 311 ppArityInfo (ArityExactly arity) = hsep [ptext SLIT("__A"), int arity]
 312 ppArityInfo (ArityAtLeast arity) = hsep [ptext SLIT("__AL"), int arity]
 313 \end{code}
 314
 315 %************************************************************************
 316 %*                                                                      *
 317 \subsection{Inline-pragma information}
 318 %*                                                                      *
 319 %************************************************************************
 320
 321 \begin{code}
 322 data InlinePragInfo
 323   = NoInlinePragInfo
 324   | IMustNotBeINLINEd Bool              -- True <=> came from an INLINE prag, False <=> came from a NOINLINE prag
 325                       (Maybe Int)       -- Phase number from pragma, if any
 326         -- The True, Nothing case doesn't need to be recorded
 327
 328         -- SEE COMMENTS WITH CoreUnfold.blackListed on the
 329         -- exact significance of the IMustNotBeINLINEd pragma
 330
 331 isNeverInlinePrag :: InlinePragInfo -> Bool
 332 isNeverInlinePrag (IMustNotBeINLINEd True Nothing) = True
 333 isNeverInlinePrag other                            = False
 334
 335 neverInlinePrag :: InlinePragInfo
 336 neverInlinePrag = IMustNotBeINLINEd True Nothing
 337
 338 instance Outputable InlinePragInfo where
 339   -- This is now parsed in interface files
 340   ppr NoInlinePragInfo = empty
 341   ppr other_prag       = ptext SLIT("__U") <> pprInlinePragInfo other_prag
 342
 343 pprInlinePragInfo NoInlinePragInfo                   = empty
 344 pprInlinePragInfo (IMustNotBeINLINEd True Nothing)   = empty
 345 pprInlinePragInfo (IMustNotBeINLINEd True (Just n))  = brackets (int n)
 346 pprInlinePragInfo (IMustNotBeINLINEd False Nothing)  = brackets (char '!')
 347 pprInlinePragInfo (IMustNotBeINLINEd False (Just n)) = brackets (char '!' <> int n)
 348
 349 instance Show InlinePragInfo where
 350   showsPrec p prag = showsPrecSDoc p (ppr prag)
 351 \end{code}
 352
 353
 354 %************************************************************************
 355 %*                                                                      *
 356 \subsection[worker-IdInfo]{Worker info about an @Id@}
 357 %*                                                                      *
 358 %************************************************************************
 359
 360 If this Id has a worker then we store a reference to it. Worker
 361 functions are generated by the worker/wrapper pass.  This uses
 362 information from the strictness and CPR analyses.
 363
 364 There might not be a worker, even for a strict function, because:
 365 (a) the function might be small enough to inline, so no need
 366     for w/w split
 367 (b) the strictness info might be "SSS" or something, so no w/w split.
 368
 369 \begin{code}
 370
 371 data WorkerInfo = NoWorker
 372                 | HasWorker Id Arity
 373         -- The Arity is the arity of the *wrapper* at the moment of the
 374         -- w/w split. It had better be the same as the arity of the wrapper
 375         -- at the moment it is spat into the interface file.
 376         -- This Arity just lets us make a (hopefully redundant) sanity check
 377
 378 seqWorker :: WorkerInfo -> ()
 379 seqWorker (HasWorker id _) = id `seq` ()
 380 seqWorker NoWorker         = ()
 381
 382 ppWorkerInfo NoWorker            = empty
 383 ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
 384
 385 noWorkerInfo = NoWorker
 386
 387 workerExists :: WorkerInfo -> Bool
 388 workerExists NoWorker        = False
 389 workerExists (HasWorker _ _) = True
 390
 391 workerId :: WorkerInfo -> Id
 392 workerId (HasWorker id _) = id
 393
 394 wrapperArity :: WorkerInfo -> Arity
 395 wrapperArity (HasWorker _ a) = a
 396 \end{code}
 397
 398
 399 %************************************************************************
 400 %*                                                                      *
 401 \subsection[update-IdInfo]{Update-analysis info about an @Id@}
 402 %*                                                                      *
 403 %************************************************************************
 404
 405 \begin{code}
 406 data UpdateInfo
 407   = NoUpdateInfo
 408   | SomeUpdateInfo UpdateSpec
 409   deriving (Eq, Ord)
 410       -- we need Eq/Ord to cross-chk update infos in interfaces
 411
 412 -- the form in which we pass update-analysis info between modules:
 413 type UpdateSpec = [Int]
 414 \end{code}
 415
 416 \begin{code}
 417 mkUpdateInfo = SomeUpdateInfo
 418
 419 updateInfoMaybe NoUpdateInfo        = Nothing
 420 updateInfoMaybe (SomeUpdateInfo []) = Nothing
 421 updateInfoMaybe (SomeUpdateInfo  u) = Just u
 422 \end{code}
 423
 424 Text instance so that the update annotations can be read in.
 425
 426 \begin{code}
 427 ppUpdateInfo NoUpdateInfo          = empty
 428 ppUpdateInfo (SomeUpdateInfo [])   = empty
 429 ppUpdateInfo (SomeUpdateInfo spec) = (<>) (ptext SLIT("__UA ")) (hcat (map int spec))
 430   -- was "__U "; changed to avoid conflict with unfoldings.  KSW 1999-07.
 431 \end{code}
 432
 433 %************************************************************************
 434 %*                                                                      *
 435 \subsection[CAF-IdInfo]{CAF-related information}
 436 %*                                                                      *
 437 %************************************************************************
 438
 439 This information is used to build Static Reference Tables (see
 440 simplStg/ComputeSRT.lhs).
 441
 442 \begin{code}
 443 data CafInfo
 444         = MayHaveCafRefs                -- either:
 445                                         -- (1) A function or static constructor
 446                                         --     that refers to one or more CAFs,
 447                                         -- (2) A real live CAF
 448
 449         | NoCafRefs                     -- A function or static constructor
 450                                         -- that refers to no CAFs.
 451
 452 -- LATER: not sure how easy this is...
 453 --      | OneCafRef Id
 454
 455
 456 seqCaf c = c `seq` ()
 457
 458 ppCafInfo NoCafRefs = ptext SLIT("__C")
 459 ppCafInfo MayHaveCafRefs = empty
 460 \end{code}
 461
 462
 463 %************************************************************************
 464 %*                                                                      *
 465 \subsection[cpr-IdInfo]{Constructed Product Result info about an @Id@}
 466 %*                                                                      *
 467 %************************************************************************
 468
 469 If the @Id@ is a function then it may have CPR info. A CPR analysis
 470 phase detects whether:
 471
 472 \begin{enumerate}
 473 \item
 474 The function's return value has a product type, i.e. an algebraic  type
 475 with a single constructor. Examples of such types are tuples and boxed
 476 primitive values.
 477 \item
 478 The function always 'constructs' the value that it is returning.  It
 479 must do this on every path through,  and it's OK if it calls another
 480 function which constructs the result.
 481 \end{enumerate}
 482
 483 If this is the case then we store a template which tells us the
 484 function has the CPR property and which components of the result are
 485 also CPRs.
 486
 487 \begin{code}
 488 data CprInfo
 489   = NoCPRInfo
 490   | ReturnsCPR  -- Yes, this function returns a constructed product
 491                 -- Implicitly, this means "after the function has been applied
 492                 -- to all its arguments", so the worker/wrapper builder in
 493                 -- WwLib.mkWWcpr checks that that it is indeed saturated before
 494                 -- making use of the CPR info
 495
 496         -- We used to keep nested info about sub-components, but
 497         -- we never used it so I threw it away
 498 \end{code}
 499
 500 \begin{code}
 501 seqCpr :: CprInfo -> ()
 502 seqCpr ReturnsCPR = ()
 503 seqCpr NoCPRInfo  = ()
 504
 505 noCprInfo       = NoCPRInfo
 506
 507 ppCprInfo NoCPRInfo  = empty
 508 ppCprInfo ReturnsCPR = ptext SLIT("__M")
 509
 510 instance Outputable CprInfo where
 511     ppr = ppCprInfo
 512
 513 instance Show CprInfo where
 514     showsPrec p c = showsPrecSDoc p (ppr c)
 515 \end{code}
 516
 517
 518 %************************************************************************
 519 %*                                                                      *
 520 \subsection[lbvar-IdInfo]{Lambda-bound var info about an @Id@}
 521 %*                                                                      *
 522 %************************************************************************
 523
 524 If the @Id@ is a lambda-bound variable then it may have lambda-bound
 525 var info.  The usage analysis (UsageSP) detects whether the lambda
 526 binding this var is a ``one-shot'' lambda; that is, whether it is
 527 applied at most once.
 528
 529 This information may be useful in optimisation, as computations may
 530 safely be floated inside such a lambda without risk of duplicating
 531 work.
 532
 533 \begin{code}
 534 data LBVarInfo
 535   = NoLBVarInfo
 536
 537   | IsOneShotLambda             -- The lambda that binds this Id is applied
 538                                 --   at most once
 539                                 -- HACK ALERT! placing this info here is a short-term hack,
 540                                 --   but it minimises changes to the rest of the compiler.
 541                                 --   Hack agreed by SLPJ/KSW 1999-04.
 542
 543 seqLBVar l = l `seq` ()
 544 \end{code}
 545
 546 \begin{code}
 547 noLBVarInfo = NoLBVarInfo
 548
 549 -- not safe to print or parse LBVarInfo because it is not really a
 550 -- property of the definition, but a property of the context.
 551 pprLBVarInfo NoLBVarInfo     = empty
 552 pprLBVarInfo IsOneShotLambda = getPprStyle $ \ sty ->
 553                                if ifaceStyle sty then empty
 554                                                  else ptext SLIT("OneShot")
 555
 556 instance Outputable LBVarInfo where
 557     ppr = pprLBVarInfo
 558
 559 instance Show LBVarInfo where
 560     showsPrec p c = showsPrecSDoc p (ppr c)
 561 \end{code}
 562
 563
 564 %************************************************************************
 565 %*                                                                      *
 566 \subsection{Bulk operations on IdInfo}
 567 %*                                                                      *
 568 %************************************************************************
 569
 570 zapFragileInfo is used when cloning binders, mainly in the
 571 simplifier.  We must forget about used-once information because that
 572 isn't necessarily correct in the transformed program.
 573 Also forget specialisations and unfoldings because they would need
 574 substitution to be correct.  (They get pinned back on separately.)
 575
 576 \begin{code}
 577 zapFragileInfo :: IdInfo -> Maybe IdInfo
 578 zapFragileInfo info@(IdInfo {occInfo            = occ,
 579                              workerInfo         = wrkr,
 580                              specInfo           = rules,
 581                              unfoldingInfo      = unfolding})
 582   |  not (isFragileOccInfo occ)
 583         -- We must forget about whether it was marked safe-to-inline,
 584         -- because that isn't necessarily true in the simplified expression.
 585         -- This is important because expressions may  be re-simplified
 586         -- We don't zap deadness or loop-breaker-ness.
 587         -- The latter is important because it tells MkIface not to
 588         -- spit out an inlining for the thing.  The former doesn't
 589         -- seem so important, but there's no harm.
 590
 591   && isEmptyCoreRules rules
 592         -- Specialisations would need substituting.  They get pinned
 593         -- back on separately.
 594
 595   && not (workerExists wrkr)
 596
 597   && not (hasUnfolding unfolding)
 598         -- This is very important; occasionally a let-bound binder is used
 599         -- as a binder in some lambda, in which case its unfolding is utterly
 600         -- bogus.  Also the unfolding uses old binders so if we left it we'd
 601         -- have to substitute it. Much better simply to give the Id a new
 602         -- unfolding each time, which is what the simplifier does.
 603   = Nothing
 604
 605   | otherwise
 606   = Just (info {occInfo         = robust_occ_info,
 607                 workerInfo      = noWorkerInfo,
 608                 specInfo        = emptyCoreRules,
 609                 unfoldingInfo   = noUnfolding})
 610   where
 611         -- It's important to keep the loop-breaker info,
 612         -- because the substitution doesn't remember it.
 613     robust_occ_info = case occ of
 614                         OneOcc _ _ -> NoOccInfo
 615                         other      -> occ
 616 \end{code}
 617
 618 @zapLamInfo@ is used for lambda binders that turn out to to be
 619 part of an unsaturated lambda
 620
 621 \begin{code}
 622 zapLamInfo :: IdInfo -> Maybe IdInfo
 623 zapLamInfo info@(IdInfo {occInfo = occ, demandInfo = demand})
 624   | is_safe_occ && not (isStrict demand)
 625   = Nothing
 626   | otherwise
 627   = Just (info {occInfo = safe_occ,
 628                 demandInfo = wwLazy})
 629   where
 630         -- The "unsafe" occ info is the ones that say I'm not in a lambda
 631         -- because that might not be true for an unsaturated lambda
 632     is_safe_occ = case occ of
 633                         OneOcc in_lam once -> in_lam
 634                         other              -> True
 635
 636     safe_occ = case occ of
 637                  OneOcc _ once -> OneOcc insideLam once
 638                  other         -> occ
 639 \end{code}
 640
 641
 642 copyIdInfo is used when shorting out a top-level binding
 643         f_local = BIG
 644         f = f_local
 645 where f is exported.  We are going to swizzle it around to
 646         f = BIG
 647         f_local = f
 648 but we must be careful to combine their IdInfos right.
 649 The fact that things can go wrong here is a bad sign, but I can't see
 650 how to make it 'patently right', so copyIdInfo is derived (pretty much) by trial and error
 651
 652 Here 'from' is f_local, 'to' is f, and the result is attached to f
 653
 654 \begin{code}
 655 copyIdInfo :: IdInfo    -- From
 656            -> IdInfo    -- To
 657            -> IdInfo    -- To, updated with stuff from From; except flavour unchanged
 658 copyIdInfo from to = from { flavourInfo = flavourInfo to,
 659                             specInfo = specInfo to,
 660                             inlinePragInfo = inlinePragInfo to
 661                           }
 662         -- It's important to preserve the inline pragma on 'f'; e.g. consider
 663         --      {-# NOINLINE f #-}
 664         --      f = local
 665         --
 666         -- similarly, transformation rules may be attached to f
 667         -- and we want to preserve them.
 668         --
 669         -- On the other hand, we want the strictness info from f_local.
 670 \end{code}