\begin{code}
module IdInfo (
- IdInfo, -- Abstract
+ GlobalIdDetails(..), notGlobalId, -- Not abstract
- vanillaIdInfo, mkIdInfo, seqIdInfo, megaSeqIdInfo,
+ IdInfo, -- Abstract
+ vanillaIdInfo, noTyGenIdInfo, noCafOrTyGenIdInfo, noCafIdInfo,
+ seqIdInfo, megaSeqIdInfo,
-- Zapping
- zapFragileInfo, zapLamInfo, zapSpecPragInfo, shortableIdInfo, copyIdInfo,
-
- -- Flavour
- IdFlavour(..), flavourInfo,
- setNoDiscardInfo,
- ppFlavourInfo,
+ zapLamInfo, zapDemandInfo,
+ shortableIdInfo, copyIdInfo,
-- Arity
ArityInfo(..),
specInfo, setSpecInfo,
-- CAF info
- CafInfo(..), cafInfo, setCafInfo, ppCafInfo,
+ CafInfo(..), cafInfo, setCafInfo, mayHaveCafRefs, ppCafInfo,
-- Constructed Product Result Info
CprInfo(..), cprInfo, setCprInfo, ppCprInfo, noCprInfo,
-- Lambda-bound variable info
- LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo
+ LBVarInfo(..), lbvarInfo, setLBVarInfo, noLBVarInfo, hasNoLBVarInfo
) where
#include "HsVersions.h"
-- infixl so you can say (id `set` a `set` b)
\end{code}
+%************************************************************************
+%* *
+\subsection{GlobalIdDetails
+%* *
+%************************************************************************
+
+This type is here (rather than in Id.lhs) mainly because there's
+an IdInfo.hi-boot, but no Id.hi-boot, and GlobalIdDetails is imported
+(recursively) by Var.lhs.
+
+\begin{code}
+data GlobalIdDetails
+ = VanillaGlobal -- Imported from elsewhere, a default method Id.
+
+ | RecordSelId FieldLabel -- The Id for a record selector
+ | DataConId DataCon -- The Id for a data constructor *worker*
+ | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
+ -- [the only reasons we need to know is so that
+ -- a) we can suppress printing a definition in the interface file
+ -- b) when typechecking a pattern we can get from the
+ -- Id back to the data con]
+
+ | PrimOpId PrimOp -- The Id for a primitive operator
+
+ | NotGlobalId -- Used as a convenient extra return value from globalIdDetails
+
+notGlobalId = NotGlobalId
+
+instance Outputable GlobalIdDetails where
+ ppr NotGlobalId = ptext SLIT("[***NotGlobalId***]")
+ ppr VanillaGlobal = ptext SLIT("[GlobalId]")
+ ppr (DataConId _) = ptext SLIT("[DataCon]")
+ ppr (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
+ ppr (PrimOpId _) = ptext SLIT("[PrimOp]")
+ ppr (RecordSelId _) = ptext SLIT("[RecSel]")
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{The main IdInfo type}
+%* *
+%************************************************************************
+
An @IdInfo@ gives {\em optional} information about an @Id@. If
present it never lies, but it may not be present, in which case there
is always a conservative assumption which can be made.
- There is one exception: the 'flavour' is *not* optional.
- You must not discard it.
- It used to be in Var.lhs, but that seems unclean.
-
Two @Id@s may have different info even though they have the same
@Unique@ (and are hence the same @Id@); for example, one might lack
the properties attached to the other.
\begin{code}
data IdInfo
= IdInfo {
- flavourInfo :: IdFlavour, -- NOT OPTIONAL
arityInfo :: ArityInfo, -- Its arity
demandInfo :: Demand, -- Whether or not it is definitely demanded
specInfo :: CoreRules, -- Specialisations of this function which exist
strictnessInfo :: StrictnessInfo, -- Strictness properties
workerInfo :: WorkerInfo, -- Pointer to Worker Function
unfoldingInfo :: Unfolding, -- Its unfolding
- cafInfo :: CafInfo,
+ cafInfo :: CafInfo, -- whether it refers (indirectly) to any CAFs
cprInfo :: CprInfo, -- Function always constructs a product result
lbvarInfo :: LBVarInfo, -- Info about a lambda-bound variable
inlinePragInfo :: InlinePragInfo, -- Inline pragma
megaSeqIdInfo :: IdInfo -> ()
megaSeqIdInfo info
- = seqFlavour (flavourInfo info) `seq`
- seqArity (arityInfo info) `seq`
+ = seqArity (arityInfo info) `seq`
seqDemand (demandInfo info) `seq`
seqRules (specInfo info) `seq`
seqTyGenInfo (tyGenInfo info) `seq`
setCafInfo info cf = info { cafInfo = cf }
setCprInfo info cp = info { cprInfo = cp }
setLBVarInfo info lb = info { lbvarInfo = lb }
-
-setNoDiscardInfo info = case flavourInfo info of
- VanillaId -> info { flavourInfo = NoDiscardId }
- other -> info
-zapSpecPragInfo info = case flavourInfo info of
- SpecPragmaId -> info { flavourInfo = VanillaId }
- other -> info
\end{code}
\begin{code}
vanillaIdInfo :: IdInfo
-vanillaIdInfo = mkIdInfo VanillaId
-
-mkIdInfo :: IdFlavour -> IdInfo
-mkIdInfo flv = IdInfo {
- flavourInfo = flv,
- arityInfo = UnknownArity,
- demandInfo = wwLazy,
- specInfo = emptyCoreRules,
- tyGenInfo = noTyGenInfo,
- workerInfo = NoWorker,
- strictnessInfo = NoStrictnessInfo,
- unfoldingInfo = noUnfolding,
- cafInfo = MayHaveCafRefs,
- cprInfo = NoCPRInfo,
- lbvarInfo = NoLBVarInfo,
- inlinePragInfo = NoInlinePragInfo,
- occInfo = NoOccInfo
+vanillaIdInfo
+ = IdInfo {
+ cafInfo = MayHaveCafRefs, -- Safe!
+ arityInfo = UnknownArity,
+ demandInfo = wwLazy,
+ specInfo = emptyCoreRules,
+ tyGenInfo = noTyGenInfo,
+ workerInfo = NoWorker,
+ strictnessInfo = NoStrictnessInfo,
+ unfoldingInfo = noUnfolding,
+ cprInfo = NoCPRInfo,
+ lbvarInfo = NoLBVarInfo,
+ inlinePragInfo = NoInlinePragInfo,
+ occInfo = NoOccInfo
}
-\end{code}
+noTyGenIdInfo = vanillaIdInfo `setTyGenInfo` TyGenNever
+ -- Many built-in things have fixed types, so we shouldn't
+ -- run around generalising them
-%************************************************************************
-%* *
-\subsection{Flavour}
-%* *
-%************************************************************************
+noCafIdInfo = vanillaIdInfo `setCafInfo` NoCafRefs
+ -- Local things don't refer to Cafs
-\begin{code}
-data IdFlavour
- = VanillaId -- Most Ids are like this
- | DataConId DataCon -- The Id for a data constructor *worker*
- | DataConWrapId DataCon -- The Id for a data constructor *wrapper*
- -- [the only reasons we need to know is so that
- -- a) we can suppress printing a definition in the interface file
- -- b) when typechecking a pattern we can get from the
- -- Id back to the data con]
- | PrimOpId PrimOp -- The Id for a primitive operator
- | RecordSelId FieldLabel -- The Id for a record selector
- | SpecPragmaId -- Don't discard these
- | NoDiscardId -- Don't discard these either
-
-ppFlavourInfo :: IdFlavour -> SDoc
-ppFlavourInfo VanillaId = empty
-ppFlavourInfo (DataConId _) = ptext SLIT("[DataCon]")
-ppFlavourInfo (DataConWrapId _) = ptext SLIT("[DataConWrapper]")
-ppFlavourInfo (PrimOpId _) = ptext SLIT("[PrimOp]")
-ppFlavourInfo (RecordSelId _) = ptext SLIT("[RecSel]")
-ppFlavourInfo SpecPragmaId = ptext SLIT("[SpecPrag]")
-ppFlavourInfo NoDiscardId = ptext SLIT("[NoDiscard]")
-
-seqFlavour :: IdFlavour -> ()
-seqFlavour f = f `seq` ()
+noCafOrTyGenIdInfo = noTyGenIdInfo `setCafInfo` NoCafRefs
+ -- Most also guarantee not to refer to CAFs
\end{code}
-The @SpecPragmaId@ exists only to make Ids that are
-on the *LHS* of bindings created by SPECIALISE pragmas;
-eg: s = f Int d
-The SpecPragmaId is never itself mentioned; it
-exists solely so that the specialiser will find
-the call to f, and make specialised version of it.
-The SpecPragmaId binding is discarded by the specialiser
-when it gathers up overloaded calls.
-Meanwhile, it is not discarded as dead code.
-
%************************************************************************
%* *
ppWorkerInfo NoWorker = empty
ppWorkerInfo (HasWorker wk_id _) = ptext SLIT("__P") <+> ppr wk_id
-noWorkerInfo = NoWorker
-
workerExists :: WorkerInfo -> Bool
workerExists NoWorker = False
workerExists (HasWorker _ _) = True
-- | OneCafRef Id
+mayHaveCafRefs MayHaveCafRefs = True
+mayHaveCafRefs _ = False
+
seqCaf c = c `seq` ()
ppCafInfo NoCafRefs = ptext SLIT("__C")
\end{code}
\begin{code}
+hasNoLBVarInfo NoLBVarInfo = True
+hasNoLBVarInfo other = False
+
noLBVarInfo = NoLBVarInfo
-- not safe to print or parse LBVarInfo because it is not really a
%* *
%************************************************************************
-zapFragileInfo is used when cloning binders, mainly in the
-simplifier. We must forget about used-once information because that
-isn't necessarily correct in the transformed program.
-Also forget specialisations and unfoldings because they would need
-substitution to be correct. (They get pinned back on separately.)
-
-\begin{code}
-zapFragileInfo :: IdInfo -> Maybe IdInfo
-zapFragileInfo info@(IdInfo {occInfo = occ,
- workerInfo = wrkr,
- specInfo = rules,
- unfoldingInfo = unfolding})
- | not (isFragileOcc occ)
- -- We must forget about whether it was marked safe-to-inline,
- -- because that isn't necessarily true in the simplified expression.
- -- This is important because expressions may be re-simplified
- -- We don't zap deadness or loop-breaker-ness.
- -- The latter is important because it tells MkIface not to
- -- spit out an inlining for the thing. The former doesn't
- -- seem so important, but there's no harm.
-
- && isEmptyCoreRules rules
- -- Specialisations would need substituting. They get pinned
- -- back on separately.
-
- && not (workerExists wrkr)
-
- && not (hasUnfolding unfolding)
- -- This is very important; occasionally a let-bound binder is used
- -- as a binder in some lambda, in which case its unfolding is utterly
- -- bogus. Also the unfolding uses old binders so if we left it we'd
- -- have to substitute it. Much better simply to give the Id a new
- -- unfolding each time, which is what the simplifier does.
- = Nothing
-
- | otherwise
- = Just (info {occInfo = robust_occ_info,
- workerInfo = noWorkerInfo,
- specInfo = emptyCoreRules,
- unfoldingInfo = noUnfolding})
- where
- -- It's important to keep the loop-breaker info,
- -- because the substitution doesn't remember it.
- robust_occ_info = case occ of
- OneOcc _ _ -> NoOccInfo
- other -> occ
-\end{code}
-
@zapLamInfo@ is used for lambda binders that turn out to to be
part of an unsaturated lambda
other -> occ
\end{code}
+\begin{code}
+zapDemandInfo :: IdInfo -> Maybe IdInfo
+zapDemandInfo info@(IdInfo {demandInfo = demand})
+ | not (isStrict demand) = Nothing
+ | otherwise = Just (info {demandInfo = wwLazy})
+\end{code}
+
copyIdInfo is used when shorting out a top-level binding
f_local = BIG