{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998

\section[Id]{@Ids@: Value and constructor identifiers}
-}



-- |
-- #name_types#
-- GHC uses several kinds of name internally:
--
-- * 'GHC.Types.Name.Occurrence.OccName': see "GHC.Types.Name.Occurrence#name_types"
--
-- * 'GHC.Types.Name.Reader.RdrName': see "GHC.Types.Name.Reader#name_types"
--
-- * 'GHC.Types.Name.Name': see "GHC.Types.Name#name_types"
--
-- * 'GHC.Types.Id.Id' represents names that not only have a 'GHC.Types.Name.Name' but also a
--   'GHC.Core.TyCo.Rep.Type' and some additional details (a 'GHC.Types.Id.Info.IdInfo' and
--   one of LocalIdDetails or GlobalIdDetails) that are added,
--   modified and inspected by various compiler passes. These 'GHC.Types.Var.Var' names
--   may either be global or local, see "GHC.Types.Var#globalvslocal"
--
-- * 'GHC.Types.Var.Var': see "GHC.Types.Var#name_types"

module GHC.Types.Id (
        -- * The main types
        Var, Id, isId,

        -- * In and Out variants
        InVar,  InId,
        OutVar, OutId,

        -- ** Simple construction
        mkGlobalId, mkVanillaGlobal, mkVanillaGlobalWithInfo,
        mkLocalId, mkLocalCoVar, mkLocalIdOrCoVar,
        mkLocalIdWithInfo, mkExportedLocalId, mkExportedVanillaId,
        mkSysLocal, mkSysLocalM, mkSysLocalOrCoVar, mkSysLocalOrCoVarM,
        mkUserLocal, mkUserLocalOrCoVar,
        mkTemplateLocals, mkTemplateLocalsNum, mkTemplateLocal,
        mkScaledTemplateLocal,
        mkWorkerId,

        -- ** Taking an Id apart
        idName, idType, idMult, idScaledType, idUnique, idInfo, idDetails,
        recordSelectorTyCon,
        recordSelectorTyCon_maybe,

        -- ** Modifying an Id
        setIdName, setIdUnique, GHC.Types.Id.setIdType, setIdMult,
        updateIdTypeButNotMult, updateIdTypeAndMult, updateIdTypeAndMultM,
        setIdExported, setIdNotExported,
        globaliseId, localiseId,
        setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
        zapLamIdInfo, zapIdDemandInfo, zapIdUsageInfo, zapIdUsageEnvInfo,
        zapIdUsedOnceInfo, zapIdTailCallInfo,
        zapFragileIdInfo, zapIdDmdSig, zapStableUnfolding,
        transferPolyIdInfo, scaleIdBy, scaleVarBy,

        -- ** Predicates on Ids
        isImplicitId, isDeadBinder,
        isStrictId,
        isExportedId, isLocalId, isGlobalId,
        isRecordSelector, isNaughtyRecordSelector,
        isPatSynRecordSelector,
        isDataConRecordSelector,
        isClassOpId,
        isClassOpId_maybe, isDFunId,
        isPrimOpId, isPrimOpId_maybe,
        isFCallId, isFCallId_maybe,
        isDataConWorkId, isDataConWorkId_maybe,
        isDataConWrapId, isDataConWrapId_maybe,
        isDataConId_maybe,
        idDataCon,
        isConLikeId, isWorkerLikeId, isDeadEndId, idIsFrom,
        hasNoBinding,

        -- ** Join variables
        JoinId, JoinPointHood,
        isJoinId, idJoinPointHood, idJoinArity,
        asJoinId, asJoinId_maybe, zapJoinId,

        -- ** Inline pragma stuff
        idInlinePragma, setInlinePragma, modifyInlinePragma,
        idInlineActivation, setInlineActivation, idRuleMatchInfo,

        -- ** One-shot lambdas
        setOneShotLambda, clearOneShotLambda,
        updOneShotInfo, setIdOneShotInfo,

        -- ** Reading 'IdInfo' fields
        idArity,
        idCallArity, idFunRepArity,
        idSpecialisation, idCoreRules, idHasRules,
        idCafInfo, idLFInfo_maybe,
        idOneShotInfo,
        idOccInfo,

        IdUnfoldingFun, idUnfolding, realIdUnfolding,
        alwaysActiveUnfoldingFun, whenActiveUnfoldingFun, noUnfoldingFun,

        -- ** Writing 'IdInfo' fields
        setIdUnfolding, zapIdUnfolding, setCaseBndrEvald,
        setIdArity,
        setIdCallArity,

        setIdSpecialisation,
        setIdCafInfo,
        setIdOccInfo, zapIdOccInfo,
        setIdLFInfo,

        setIdDemandInfo,
        setIdDmdSig,
        setIdCprSig,
        setIdCbvMarks,
        idCbvMarks_maybe,
        idCbvMarkArity,
        asWorkerLikeId, asNonWorkerLikeId,

        idDemandInfo,
        idDmdSig,
        idCprSig,

        idTagSig_maybe,
        setIdTagSig
    ) where

import GHC.Prelude

import GHC.Core ( CoreRule, isStableUnfolding, evaldUnfolding
                , isCompulsoryUnfolding, Unfolding( NoUnfolding )
                , IdUnfoldingFun, isEvaldUnfolding, hasSomeUnfolding, noUnfolding )

import GHC.Types.Id.Info
import GHC.Types.Basic

-- Imported and re-exported
import GHC.Types.Var( Id, CoVar, JoinId,
            InId,  InVar,
            OutId, OutVar,
            idInfo, idDetails, setIdDetails, globaliseId,
            isId, isLocalId, isGlobalId, isExportedId,
            setIdMult, updateIdTypeAndMult, updateIdTypeButNotMult, updateIdTypeAndMultM)
import qualified GHC.Types.Var as Var

import GHC.Core.Type
import GHC.Types.RepType
import GHC.Core.DataCon
import GHC.Types.Demand
import GHC.Types.Cpr
import GHC.Types.Name
import GHC.Unit.Module
import GHC.Core.Class
import {-# SOURCE #-} GHC.Builtin.PrimOps (PrimOp)
import GHC.Types.ForeignCall
import GHC.Data.Maybe
import GHC.Types.SrcLoc
import GHC.Types.Unique
import GHC.Builtin.Uniques (mkBuiltinUnique)
import GHC.Types.Unique.Supply
import GHC.Data.FastString
import GHC.Core.Multiplicity

import GHC.Utils.Misc
import GHC.Utils.Outputable
import GHC.Utils.Panic
import GHC.Stg.InferTags.TagSig

-- infixl so you can say (id `set` a `set` b)
infixl  1 `setIdUnfolding`,
          `setIdArity`,
          `setIdCallArity`,
          `setIdOccInfo`,
          `setIdOneShotInfo`,

          `setIdSpecialisation`,
          `setInlinePragma`,
          `setInlineActivation`,
          `idCafInfo`,

          `setIdDemandInfo`,
          `setIdDmdSig`,
          `setIdCprSig`,

          `asJoinId`,
          `asJoinId_maybe`,
          `setIdCbvMarks`

{-
************************************************************************
*                                                                      *
\subsection{Basic Id manipulation}
*                                                                      *
************************************************************************
-}

idName   :: Id -> Name
idName :: Id -> Name
idName    = Id -> Name
Var.varName

idUnique :: Id -> Unique
idUnique :: Id -> Unique
idUnique  = Id -> Unique
Var.varUnique

idType   :: Id -> Kind
idType :: Id -> Kind
idType    = Id -> Kind
Var.varType

idMult :: Id -> Mult
idMult :: Id -> Kind
idMult = Id -> Kind
Var.varMult

idScaledType :: Id -> Scaled Type
idScaledType :: Id -> Scaled Kind
idScaledType Id
id = Kind -> Kind -> Scaled Kind
forall a. Kind -> a -> Scaled a
Scaled (Id -> Kind
idMult Id
id) (Id -> Kind
idType Id
id)

scaleIdBy :: Mult -> Id -> Id
scaleIdBy :: Kind -> Id -> Id
scaleIdBy Kind
m Id
id = Id -> Kind -> Id
setIdMult Id
id (Kind
m Kind -> Kind -> Kind
`mkMultMul` Id -> Kind
idMult Id
id)

-- | Like 'scaleIdBy', but skips non-Ids. Useful for scaling
-- a mixed list of ids and tyvars.
scaleVarBy :: Mult -> Var -> Var
scaleVarBy :: Kind -> Id -> Id
scaleVarBy Kind
m Id
id
  | Id -> Bool
isId Id
id   = Kind -> Id -> Id
scaleIdBy Kind
m Id
id
  | Bool
otherwise = Id
id

setIdName :: Id -> Name -> Id
setIdName :: Id -> Name -> Id
setIdName = Id -> Name -> Id
Var.setVarName

setIdUnique :: Id -> Unique -> Id
setIdUnique :: Id -> Unique -> Id
setIdUnique = Id -> Unique -> Id
Var.setVarUnique

-- | Not only does this set the 'Id' 'Type', it also evaluates the type to try and
-- reduce space usage
setIdType :: Id -> Type -> Id
setIdType :: Id -> Kind -> Id
setIdType Id
id Kind
ty = Kind -> ()
seqType Kind
ty () -> Id -> Id
forall a b. a -> b -> b
`seq` Id -> Kind -> Id
Var.setVarType Id
id Kind
ty

setIdExported :: Id -> Id
setIdExported :: Id -> Id
setIdExported = Id -> Id
Var.setIdExported

setIdNotExported :: Id -> Id
setIdNotExported :: Id -> Id
setIdNotExported = Id -> Id
Var.setIdNotExported

localiseId :: Id -> Id
-- Make an Id with the same unique and type as the
-- incoming Id, but with an *Internal* Name and *LocalId* flavour
localiseId :: Id -> Id
localiseId Id
id
  | Bool -> Bool -> Bool
forall a. HasCallStack => Bool -> a -> a
assert (Id -> Bool
isId Id
id) (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Id -> Bool
isLocalId Id
id Bool -> Bool -> Bool
&& Name -> Bool
isInternalName Name
name
  = Id
id
  | Bool
otherwise
  = IdDetails -> Name -> Kind -> Kind -> IdInfo -> Id
Var.mkLocalVar (Id -> IdDetails
idDetails Id
id) (Name -> Name
localiseName Name
name) (Id -> Kind
Var.varMult Id
id) (Id -> Kind
idType Id
id) (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)
  where
    name :: Name
name = Id -> Name
idName Id
id

lazySetIdInfo :: Id -> IdInfo -> Id
lazySetIdInfo :: Id -> IdInfo -> Id
lazySetIdInfo = Id -> IdInfo -> Id
Var.lazySetIdInfo

setIdInfo :: Id -> IdInfo -> Id
setIdInfo :: Id -> IdInfo -> Id
setIdInfo Id
id IdInfo
info = IdInfo
info IdInfo -> Id -> Id
forall a b. a -> b -> b
`seq` (Id -> IdInfo -> Id
lazySetIdInfo Id
id IdInfo
info)
        -- Try to avoid space leaks by seq'ing

modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo :: HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo IdInfo -> IdInfo
fn Id
id = Id -> IdInfo -> Id
setIdInfo Id
id (IdInfo -> IdInfo
fn (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id))

-- maybeModifyIdInfo tries to avoid unnecessary thrashing
maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
maybeModifyIdInfo (Just IdInfo
new_info) Id
id = Id -> IdInfo -> Id
lazySetIdInfo Id
id IdInfo
new_info
maybeModifyIdInfo Maybe IdInfo
Nothing         Id
id = Id
id

-- maybeModifyIdInfo tries to avoid unnecessary thrashing
maybeModifyIdDetails :: Maybe IdDetails  -> Id -> Id
maybeModifyIdDetails :: Maybe IdDetails -> Id -> Id
maybeModifyIdDetails (Just IdDetails
new_details) Id
id = Id -> IdDetails -> Id
setIdDetails Id
id IdDetails
new_details
maybeModifyIdDetails Maybe IdDetails
Nothing         Id
id = Id
id

{-
************************************************************************
*                                                                      *
\subsection{Simple Id construction}
*                                                                      *
************************************************************************

Absolutely all Ids are made by mkId.  It is just like Var.mkId,
but in addition it pins free-tyvar-info onto the Id's type,
where it can easily be found.

Note [Free type variables]
~~~~~~~~~~~~~~~~~~~~~~~~~~
At one time we cached the free type variables of the type of an Id
at the root of the type in a TyNote.  The idea was to avoid repeating
the free-type-variable calculation.  But it turned out to slow down
the compiler overall. I don't quite know why; perhaps finding free
type variables of an Id isn't all that common whereas applying a
substitution (which changes the free type variables) is more common.
Anyway, we removed it in March 2008.
-}

-- | For an explanation of global vs. local 'Id's, see "GHC.Types.Var.Var#globalvslocal"
mkGlobalId :: IdDetails -> Name -> Type -> IdInfo -> Id
mkGlobalId :: IdDetails -> Name -> Kind -> IdInfo -> Id
mkGlobalId = IdDetails -> Name -> Kind -> IdInfo -> Id
Var.mkGlobalVar

-- | Make a global 'Id' without any extra information at all
mkVanillaGlobal :: Name -> Type -> Id
mkVanillaGlobal :: Name -> Kind -> Id
mkVanillaGlobal Name
name Kind
ty = Name -> Kind -> IdInfo -> Id
mkVanillaGlobalWithInfo Name
name Kind
ty IdInfo
vanillaIdInfo

-- | Make a global 'Id' with no global information but some generic 'IdInfo'
mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
mkVanillaGlobalWithInfo :: Name -> Kind -> IdInfo -> Id
mkVanillaGlobalWithInfo = IdDetails -> Name -> Kind -> IdInfo -> Id
mkGlobalId IdDetails
VanillaId


-- | For an explanation of global vs. local 'Id's, see "GHC.Types.Var#globalvslocal"
mkLocalId :: HasDebugCallStack => Name -> Mult -> Type -> Id
mkLocalId :: HasDebugCallStack => Name -> Kind -> Kind -> Id
mkLocalId Name
name Kind
w Kind
ty = HasDebugCallStack => Name -> Kind -> Kind -> IdInfo -> Id
Name -> Kind -> Kind -> IdInfo -> Id
mkLocalIdWithInfo Name
name Kind
w (Bool -> Kind -> Kind
forall a. HasCallStack => Bool -> a -> a
assert (Bool -> Bool
not (Kind -> Bool
isCoVarType Kind
ty)) Kind
ty) IdInfo
vanillaIdInfo

-- | Make a local CoVar
mkLocalCoVar :: Name -> Type -> CoVar
mkLocalCoVar :: Name -> Kind -> Id
mkLocalCoVar Name
name Kind
ty
  = Bool -> Id -> Id
forall a. HasCallStack => Bool -> a -> a
assert (Kind -> Bool
isCoVarType Kind
ty) (Id -> Id) -> Id -> Id
forall a b. (a -> b) -> a -> b
$
    IdDetails -> Name -> Kind -> Kind -> IdInfo -> Id
Var.mkLocalVar IdDetails
CoVarId Name
name Kind
ManyTy Kind
ty IdInfo
vanillaIdInfo

-- | Like 'mkLocalId', but checks the type to see if it should make a covar
mkLocalIdOrCoVar :: Name -> Mult -> Type -> Id
mkLocalIdOrCoVar :: Name -> Kind -> Kind -> Id
mkLocalIdOrCoVar Name
name Kind
w Kind
ty
  -- We should assert (eqType w Many) in the isCoVarType case.
  -- However, currently this assertion does not hold.
  -- In tests with -fdefer-type-errors, such as T14584a,
  -- we create a linear 'case' where the scrutinee is a coercion
  -- (see castBottomExpr). This problem is covered by #17291.
  | Kind -> Bool
isCoVarType Kind
ty = Name -> Kind -> Id
mkLocalCoVar Name
name   Kind
ty
  | Bool
otherwise      = HasDebugCallStack => Name -> Kind -> Kind -> Id
Name -> Kind -> Kind -> Id
mkLocalId    Name
name Kind
w Kind
ty

    -- proper ids only; no covars!
mkLocalIdWithInfo :: HasDebugCallStack => Name -> Mult -> Type -> IdInfo -> Id
mkLocalIdWithInfo :: HasDebugCallStack => Name -> Kind -> Kind -> IdInfo -> Id
mkLocalIdWithInfo Name
name Kind
w Kind
ty IdInfo
info =
  IdDetails -> Name -> Kind -> Kind -> IdInfo -> Id
Var.mkLocalVar IdDetails
VanillaId Name
name Kind
w (Bool -> Kind -> Kind
forall a. HasCallStack => Bool -> a -> a
assert (Bool -> Bool
not (Kind -> Bool
isCoVarType Kind
ty)) Kind
ty) IdInfo
info
        -- Note [Free type variables]

-- | Create a local 'Id' that is marked as exported.
-- This prevents things attached to it from being removed as dead code.
-- See Note [Exported LocalIds]
mkExportedLocalId :: IdDetails -> Name -> Type -> Id
mkExportedLocalId :: IdDetails -> Name -> Kind -> Id
mkExportedLocalId IdDetails
details Name
name Kind
ty = IdDetails -> Name -> Kind -> IdInfo -> Id
Var.mkExportedLocalVar IdDetails
details Name
name Kind
ty IdInfo
vanillaIdInfo
        -- Note [Free type variables]

mkExportedVanillaId :: Name -> Type -> Id
mkExportedVanillaId :: Name -> Kind -> Id
mkExportedVanillaId Name
name Kind
ty = IdDetails -> Name -> Kind -> IdInfo -> Id
Var.mkExportedLocalVar IdDetails
VanillaId Name
name Kind
ty IdInfo
vanillaIdInfo
        -- Note [Free type variables]


-- | Create a system local 'Id'. These are local 'Id's (see "Var#globalvslocal")
-- that are created by the compiler out of thin air
mkSysLocal :: FastString -> Unique -> Mult -> Type -> Id
mkSysLocal :: FastString -> Unique -> Kind -> Kind -> Id
mkSysLocal FastString
fs Unique
uniq Kind
w Kind
ty = Bool -> Id -> Id
forall a. HasCallStack => Bool -> a -> a
assert (Bool -> Bool
not (Kind -> Bool
isCoVarType Kind
ty)) (Id -> Id) -> Id -> Id
forall a b. (a -> b) -> a -> b
$
                        HasDebugCallStack => Name -> Kind -> Kind -> Id
Name -> Kind -> Kind -> Id
mkLocalId (Unique -> FastString -> Name
mkSystemVarName Unique
uniq FastString
fs) Kind
w Kind
ty

-- | Like 'mkSysLocal', but checks to see if we have a covar type
mkSysLocalOrCoVar :: FastString -> Unique -> Mult -> Type -> Id
mkSysLocalOrCoVar :: FastString -> Unique -> Kind -> Kind -> Id
mkSysLocalOrCoVar FastString
fs Unique
uniq Kind
w Kind
ty
  = Name -> Kind -> Kind -> Id
mkLocalIdOrCoVar (Unique -> FastString -> Name
mkSystemVarName Unique
uniq FastString
fs) Kind
w Kind
ty

mkSysLocalM :: MonadUnique m => FastString -> Mult -> Type -> m Id
mkSysLocalM :: forall (m :: * -> *).
MonadUnique m =>
FastString -> Kind -> Kind -> m Id
mkSysLocalM FastString
fs Kind
w Kind
ty = m Unique
forall (m :: * -> *). MonadUnique m => m Unique
getUniqueM m Unique -> (Unique -> m Id) -> m Id
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\Unique
uniq -> Id -> m Id
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FastString -> Unique -> Kind -> Kind -> Id
mkSysLocal FastString
fs Unique
uniq Kind
w Kind
ty))

mkSysLocalOrCoVarM :: MonadUnique m => FastString -> Mult -> Type -> m Id
mkSysLocalOrCoVarM :: forall (m :: * -> *).
MonadUnique m =>
FastString -> Kind -> Kind -> m Id
mkSysLocalOrCoVarM FastString
fs Kind
w Kind
ty
  = m Unique
forall (m :: * -> *). MonadUnique m => m Unique
getUniqueM m Unique -> (Unique -> m Id) -> m Id
forall a b. m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\Unique
uniq -> Id -> m Id
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (FastString -> Unique -> Kind -> Kind -> Id
mkSysLocalOrCoVar FastString
fs Unique
uniq Kind
w Kind
ty))

-- | Create a user local 'Id'. These are local 'Id's (see "GHC.Types.Var#globalvslocal") with a name and location that the user might recognize
mkUserLocal :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
mkUserLocal :: OccName -> Unique -> Kind -> Kind -> SrcSpan -> Id
mkUserLocal OccName
occ Unique
uniq Kind
w Kind
ty SrcSpan
loc = Bool -> Id -> Id
forall a. HasCallStack => Bool -> a -> a
assert (Bool -> Bool
not (Kind -> Bool
isCoVarType Kind
ty)) (Id -> Id) -> Id -> Id
forall a b. (a -> b) -> a -> b
$
                                HasDebugCallStack => Name -> Kind -> Kind -> Id
Name -> Kind -> Kind -> Id
mkLocalId (Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq OccName
occ SrcSpan
loc) Kind
w Kind
ty

-- | Like 'mkUserLocal', but checks if we have a coercion type
mkUserLocalOrCoVar :: OccName -> Unique -> Mult -> Type -> SrcSpan -> Id
mkUserLocalOrCoVar :: OccName -> Unique -> Kind -> Kind -> SrcSpan -> Id
mkUserLocalOrCoVar OccName
occ Unique
uniq Kind
w Kind
ty SrcSpan
loc
  = Name -> Kind -> Kind -> Id
mkLocalIdOrCoVar (Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq OccName
occ SrcSpan
loc) Kind
w Kind
ty

{-
Make some local @Ids@ for a template @CoreExpr@.  These have bogus
@Uniques@, but that's OK because the templates are supposed to be
instantiated before use.
-}

-- | Workers get local names. "CoreTidy" will externalise these if necessary
mkWorkerId :: Unique -> Id -> Type -> Id
mkWorkerId :: Unique -> Id -> Kind -> Id
mkWorkerId Unique
uniq Id
unwrkr Kind
ty
  = HasDebugCallStack => Name -> Kind -> Kind -> Id
Name -> Kind -> Kind -> Id
mkLocalId ((OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName OccName -> OccName
mkWorkerOcc Unique
uniq (Id -> Name
forall a. NamedThing a => a -> Name
getName Id
unwrkr)) Kind
ManyTy Kind
ty

-- | Create a /template local/: a family of system local 'Id's in bijection with @Int@s, typically used in unfoldings
mkTemplateLocal :: Int -> Type -> Id
mkTemplateLocal :: Arity -> Kind -> Id
mkTemplateLocal Arity
i Kind
ty = Arity -> Scaled Kind -> Id
mkScaledTemplateLocal Arity
i (Kind -> Scaled Kind
forall a. a -> Scaled a
unrestricted Kind
ty)

mkScaledTemplateLocal :: Int -> Scaled Type -> Id
mkScaledTemplateLocal :: Arity -> Scaled Kind -> Id
mkScaledTemplateLocal Arity
i (Scaled Kind
w Kind
ty) = FastString -> Unique -> Kind -> Kind -> Id
mkSysLocalOrCoVar (String -> FastString
fsLit String
"v") (Arity -> Unique
mkBuiltinUnique Arity
i) Kind
w Kind
ty
   -- "OrCoVar" since this is used in a superclass selector,
   -- and "~" and "~~" have coercion "superclasses".

-- | Create a template local for a series of types
mkTemplateLocals :: [Type] -> [Id]
mkTemplateLocals :: [Kind] -> [Id]
mkTemplateLocals = Arity -> [Kind] -> [Id]
mkTemplateLocalsNum Arity
1

-- | Create a template local for a series of type, but start from a specified template local
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
mkTemplateLocalsNum :: Arity -> [Kind] -> [Id]
mkTemplateLocalsNum Arity
n [Kind]
tys = (Arity -> Kind -> Id) -> [Arity] -> [Kind] -> [Id]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Arity -> Kind -> Id
mkTemplateLocal [Arity
n..] [Kind]
tys

{- Note [Exported LocalIds]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
We use mkExportedLocalId for things like
 - Dictionary functions (DFunId)
 - Wrapper and matcher Ids for pattern synonyms
 - Default methods for classes
 - Pattern-synonym matcher and builder Ids
 - etc

They marked as "exported" in the sense that they should be kept alive
even if apparently unused in other bindings, and not dropped as dead
code by the occurrence analyser.  (But "exported" here does not mean
"brought into lexical scope by an import declaration". Indeed these
things are always internal Ids that the user never sees.)

It's very important that they are *LocalIds*, not GlobalIds, for lots
of reasons:

 * We want to treat them as free variables for the purpose of
   dependency analysis (e.g. GHC.Core.FVs.exprFreeVars).

 * Look them up in the current substitution when we come across
   occurrences of them (in Subst.lookupIdSubst). Lacking this we
   can get an out-of-date unfolding, which can in turn make the
   simplifier go into an infinite loop (#9857)

 * Ensure that for dfuns that the specialiser does not float dict uses
   above their defns, which would prevent good simplifications happening.

 * The strictness analyser treats a occurrence of a GlobalId as
   imported and assumes it contains strictness in its IdInfo, which
   isn't true if the thing is bound in the same module as the
   occurrence.

In CoreTidy we must make all these LocalIds into GlobalIds, so that in
importing modules (in --make mode) we treat them as properly global.
That is what is happening in, say tidy_insts in GHC.Iface.Tidy.

************************************************************************
*                                                                      *
\subsection{Special Ids}
*                                                                      *
************************************************************************
-}

-- | If the 'Id' is that for a record selector, extract the 'sel_tycon'. Panic otherwise.
recordSelectorTyCon :: Id -> RecSelParent
recordSelectorTyCon :: Id -> RecSelParent
recordSelectorTyCon Id
id
  = case Id -> Maybe RecSelParent
recordSelectorTyCon_maybe Id
id of
        Just RecSelParent
parent -> RecSelParent
parent
        Maybe RecSelParent
_ -> String -> RecSelParent
forall a. HasCallStack => String -> a
panic String
"recordSelectorTyCon"

recordSelectorTyCon_maybe :: Id -> Maybe RecSelParent
recordSelectorTyCon_maybe :: Id -> Maybe RecSelParent
recordSelectorTyCon_maybe Id
id
  = case Id -> IdDetails
Var.idDetails Id
id of
        RecSelId { sel_tycon :: IdDetails -> RecSelParent
sel_tycon = RecSelParent
parent } -> RecSelParent -> Maybe RecSelParent
forall a. a -> Maybe a
Just RecSelParent
parent
        IdDetails
_ -> Maybe RecSelParent
forall a. Maybe a
Nothing

isRecordSelector        :: Id -> Bool
isNaughtyRecordSelector :: Id -> Bool
isPatSynRecordSelector  :: Id -> Bool
isDataConRecordSelector  :: Id -> Bool
isPrimOpId              :: Id -> Bool
isFCallId               :: Id -> Bool
isDataConWorkId         :: Id -> Bool
isDataConWrapId         :: Id -> Bool
isDFunId                :: Id -> Bool
isClassOpId             :: Id -> Bool

isClassOpId_maybe       :: Id -> Maybe Class
isPrimOpId_maybe        :: Id -> Maybe PrimOp
isFCallId_maybe         :: Id -> Maybe ForeignCall
isDataConWorkId_maybe   :: Id -> Maybe DataCon
isDataConWrapId_maybe   :: Id -> Maybe DataCon

isRecordSelector :: Id -> Bool
isRecordSelector Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        RecSelId {}     -> Bool
True
                        IdDetails
_               -> Bool
False

isDataConRecordSelector :: Id -> Bool
isDataConRecordSelector Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        RecSelId {sel_tycon :: IdDetails -> RecSelParent
sel_tycon = RecSelData TyCon
_} -> Bool
True
                        IdDetails
_                                   -> Bool
False

isPatSynRecordSelector :: Id -> Bool
isPatSynRecordSelector Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        RecSelId {sel_tycon :: IdDetails -> RecSelParent
sel_tycon = RecSelPatSyn PatSyn
_} -> Bool
True
                        IdDetails
_                                     -> Bool
False

isNaughtyRecordSelector :: Id -> Bool
isNaughtyRecordSelector Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        RecSelId { sel_naughty :: IdDetails -> Bool
sel_naughty = Bool
n } -> Bool
n
                        IdDetails
_                            -> Bool
False

isClassOpId :: Id -> Bool
isClassOpId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        ClassOpId {} -> Bool
True
                        IdDetails
_other       -> Bool
False

isClassOpId_maybe :: Id -> Maybe Class
isClassOpId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        ClassOpId Class
cls Bool
_ -> Class -> Maybe Class
forall a. a -> Maybe a
Just Class
cls
                        IdDetails
_other          -> Maybe Class
forall a. Maybe a
Nothing

isPrimOpId :: Id -> Bool
isPrimOpId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        PrimOpId {} -> Bool
True
                        IdDetails
_           -> Bool
False

isDFunId :: Id -> Bool
isDFunId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        DFunId {} -> Bool
True
                        IdDetails
_         -> Bool
False

isPrimOpId_maybe :: Id -> Maybe PrimOp
isPrimOpId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        PrimOpId PrimOp
op ConcreteTyVars
_ -> PrimOp -> Maybe PrimOp
forall a. a -> Maybe a
Just PrimOp
op
                        IdDetails
_             -> Maybe PrimOp
forall a. Maybe a
Nothing

isFCallId :: Id -> Bool
isFCallId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        FCallId ForeignCall
_ -> Bool
True
                        IdDetails
_         -> Bool
False

isFCallId_maybe :: Id -> Maybe ForeignCall
isFCallId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        FCallId ForeignCall
call -> ForeignCall -> Maybe ForeignCall
forall a. a -> Maybe a
Just ForeignCall
call
                        IdDetails
_            -> Maybe ForeignCall
forall a. Maybe a
Nothing

isDataConWorkId :: Id -> Bool
isDataConWorkId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        DataConWorkId DataCon
_ -> Bool
True
                        IdDetails
_               -> Bool
False

isDataConWorkId_maybe :: Id -> Maybe DataCon
isDataConWorkId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        DataConWorkId DataCon
con -> DataCon -> Maybe DataCon
forall a. a -> Maybe a
Just DataCon
con
                        IdDetails
_                 -> Maybe DataCon
forall a. Maybe a
Nothing

isDataConWrapId :: Id -> Bool
isDataConWrapId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        DataConWrapId DataCon
_ -> Bool
True
                        IdDetails
_               -> Bool
False

isDataConWrapId_maybe :: Id -> Maybe DataCon
isDataConWrapId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                        DataConWrapId DataCon
con -> DataCon -> Maybe DataCon
forall a. a -> Maybe a
Just DataCon
con
                        IdDetails
_                 -> Maybe DataCon
forall a. Maybe a
Nothing

isDataConId_maybe :: Id -> Maybe DataCon
isDataConId_maybe :: Id -> Maybe DataCon
isDataConId_maybe Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                         DataConWorkId DataCon
con -> DataCon -> Maybe DataCon
forall a. a -> Maybe a
Just DataCon
con
                         DataConWrapId DataCon
con -> DataCon -> Maybe DataCon
forall a. a -> Maybe a
Just DataCon
con
                         IdDetails
_                 -> Maybe DataCon
forall a. Maybe a
Nothing

-- | An Id for which we might require all callers to pass strict arguments properly tagged + evaluated.
--
-- See Note [CBV Function Ids]
isWorkerLikeId :: Id -> Bool
isWorkerLikeId :: Id -> Bool
isWorkerLikeId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
  WorkerLikeId [CbvMark]
_  -> Bool
True
  JoinId Arity
_ Just{}   -> Bool
True
  IdDetails
_                 -> Bool
False

isJoinId :: Var -> Bool
-- It is convenient in GHC.Core.Opt.SetLevels.lvlMFE to apply isJoinId
-- to the free vars of an expression, so it's convenient
-- if it returns False for type variables
isJoinId :: Id -> Bool
isJoinId Id
id
  | Id -> Bool
isId Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                JoinId {} -> Bool
True
                IdDetails
_         -> Bool
False
  | Bool
otherwise = Bool
False

-- | Doesn't return strictness marks
idJoinPointHood :: Var -> JoinPointHood
idJoinPointHood :: Id -> JoinPointHood
idJoinPointHood Id
id
 | Id -> Bool
isId Id
id  = case Id -> IdDetails
Var.idDetails Id
id of
                JoinId Arity
arity Maybe [CbvMark]
_marks -> Arity -> JoinPointHood
JoinPoint Arity
arity
                IdDetails
_                   -> JoinPointHood
NotJoinPoint
 | Bool
otherwise = JoinPointHood
NotJoinPoint

idDataCon :: Id -> DataCon
-- ^ Get from either the worker or the wrapper 'Id' to the 'DataCon'. Currently used only in the desugarer.
--
-- INVARIANT: @idDataCon (dataConWrapId d) = d@: remember, 'dataConWrapId' can return either the wrapper or the worker
idDataCon :: Id -> DataCon
idDataCon Id
id = Id -> Maybe DataCon
isDataConId_maybe Id
id Maybe DataCon -> DataCon -> DataCon
forall a. Maybe a -> a -> a
`orElse` String -> SDoc -> DataCon
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"idDataCon" (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id)

hasNoBinding :: Id -> Bool
-- ^ Returns @True@ of an 'Id' which may not have a
-- binding, even though it is defined in this module.

-- Data constructor workers used to be things of this kind, but they aren't any
-- more.  Instead, we inject a binding for them at the CorePrep stage. The
-- exception to this is unboxed tuples and sums datacons, which definitely have
-- no binding
hasNoBinding :: Id -> Bool
hasNoBinding Id
id = case Id -> IdDetails
Var.idDetails Id
id of

-- TEMPORARILY make all primops hasNoBinding, to avoid #20155
-- The goal is to understand #20155 and revert to the commented out version
                        PrimOpId PrimOp
_ ConcreteTyVars
_ -> Bool
True    -- See Note [Eta expanding primops] in GHC.Builtin.PrimOps
--                        PrimOpId _ lev_poly -> lev_poly    -- TEMPORARILY commented out

                        FCallId ForeignCall
_        -> Bool
True
                        DataConWorkId DataCon
dc -> DataCon -> Bool
isUnboxedTupleDataCon DataCon
dc Bool -> Bool -> Bool
|| DataCon -> Bool
isUnboxedSumDataCon DataCon
dc
                        IdDetails
_                -> Unfolding -> Bool
isCompulsoryUnfolding (Id -> Unfolding
realIdUnfolding Id
id)
  -- Note: this function must be very careful not to force
  -- any of the fields that aren't the 'uf_src' field of
  -- the 'Unfolding' of the 'Id'. This is because these fields are computed
  -- in terms of the 'uf_tmpl' field, which is not available
  -- until we have finished Core Lint for the unfolding, which calls 'hasNoBinding'
  -- in 'checkCanEtaExpand'.
  --
  -- In particular, calling 'idUnfolding' rather than 'realIdUnfolding' here can
  -- force the 'uf_tmpl' field, because 'trimUnfolding' forces the 'uf_is_value' field,
  -- and this field is usually computed in terms of the 'uf_tmpl' field,
  -- so we will force that as well.
  --
  -- See Note [Lazily checking Unfoldings] in GHC.IfaceToCore.

isImplicitId :: Id -> Bool
-- ^ 'isImplicitId' tells whether an 'Id's info is implied by other
-- declarations, so we don't need to put its signature in an interface
-- file, even if it's mentioned in some other interface unfolding.
isImplicitId :: Id -> Bool
isImplicitId Id
id
  = case Id -> IdDetails
Var.idDetails Id
id of
        FCallId {}       -> Bool
True
        ClassOpId {}     -> Bool
True
        PrimOpId {}      -> Bool
True
        DataConWorkId {} -> Bool
True
        DataConWrapId {} -> Bool
True
                -- These are implied by their type or class decl;
                -- remember that all type and class decls appear in the interface file.
                -- The dfun id is not an implicit Id; it must *not* be omitted, because
                -- it carries version info for the instance decl
        IdDetails
_               -> Bool
False

idIsFrom :: Module -> Id -> Bool
idIsFrom :: Module -> Id -> Bool
idIsFrom Module
mod Id
id = Module -> Name -> Bool
nameIsLocalOrFrom Module
mod (Id -> Name
idName Id
id)

isDeadBinder :: Id -> Bool
isDeadBinder :: Id -> Bool
isDeadBinder Id
bndr | Id -> Bool
isId Id
bndr = OccInfo -> Bool
isDeadOcc (Id -> OccInfo
idOccInfo Id
bndr)
                  | Bool
otherwise = Bool
False   -- TyVars count as not dead

{-
************************************************************************
*                                                                      *
              Join variables
*                                                                      *
************************************************************************
-}

idJoinArity :: JoinId -> JoinArity
idJoinArity :: Id -> Arity
idJoinArity Id
id = case Id -> JoinPointHood
idJoinPointHood Id
id of
                   JoinPoint Arity
ar -> Arity
ar
                   JoinPointHood
NotJoinPoint -> String -> SDoc -> Arity
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"idJoinArity" (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id)

asJoinId :: Id -> JoinArity -> JoinId
asJoinId :: Id -> Arity -> Id
asJoinId Id
id Arity
arity = Bool -> String -> SDoc -> Id -> Id
forall a. HasCallStack => Bool -> String -> SDoc -> a -> a
warnPprTrace (Bool -> Bool
not (Id -> Bool
isLocalId Id
id))
                         String
"global id being marked as join var"  (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id) (Id -> Id) -> Id -> Id
forall a b. (a -> b) -> a -> b
$
                    Bool -> String -> SDoc -> Id -> Id
forall a. HasCallStack => Bool -> String -> SDoc -> a -> a
warnPprTrace (Bool -> Bool
not (Id -> Bool
is_vanilla_or_join Id
id))
                         String
"asJoinId"
                         (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> IdDetails -> SDoc
pprIdDetails (Id -> IdDetails
idDetails Id
id)) (Id -> Id) -> Id -> Id
forall a b. (a -> b) -> a -> b
$
                    Id
id Id -> IdDetails -> Id
`setIdDetails` Arity -> Maybe [CbvMark] -> IdDetails
JoinId Arity
arity (Id -> Maybe [CbvMark]
idCbvMarks_maybe Id
id)
  where
    is_vanilla_or_join :: Id -> Bool
is_vanilla_or_join Id
id = case Id -> IdDetails
Var.idDetails Id
id of
                              IdDetails
VanillaId -> Bool
True
                              -- Can workers become join ids? Yes!
                              WorkerLikeId {} -> String -> SDoc -> Bool -> Bool
forall a. String -> SDoc -> a -> a
pprTraceDebug String
"asJoinId (call by value function)" (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id) Bool
True
                              JoinId {} -> Bool
True
                              IdDetails
_         -> Bool
False

zapJoinId :: Id -> Id
-- May be a regular id already
zapJoinId :: Id -> Id
zapJoinId Id
jid | Id -> Bool
isJoinId Id
jid = Id -> Id
zapIdTailCallInfo (IdDetails
newIdDetails IdDetails -> Id -> Id
forall a b. a -> b -> b
`seq` Id
jid Id -> IdDetails -> Id
`setIdDetails` IdDetails
newIdDetails)
                                 -- Core Lint may complain if still marked
                                 -- as AlwaysTailCalled
              | Bool
otherwise    = Id
jid
              where
                newIdDetails :: IdDetails
newIdDetails = case Id -> IdDetails
idDetails Id
jid of
                  -- We treat join points as CBV functions. Even after they are floated out.
                  -- See Note [Use CBV semantics only for join points and workers]
                  JoinId Arity
_ (Just [CbvMark]
marks) -> [CbvMark] -> IdDetails
WorkerLikeId [CbvMark]
marks
                  JoinId Arity
_ Maybe [CbvMark]
Nothing      -> [CbvMark] -> IdDetails
WorkerLikeId []
                  IdDetails
_                     -> String -> IdDetails
forall a. HasCallStack => String -> a
panic String
"zapJoinId: newIdDetails can only be used if Id was a join Id."


asJoinId_maybe :: Id -> JoinPointHood -> Id
asJoinId_maybe :: Id -> JoinPointHood -> Id
asJoinId_maybe Id
id (JoinPoint Arity
arity) = Id -> Arity -> Id
asJoinId Id
id Arity
arity
asJoinId_maybe Id
id JoinPointHood
NotJoinPoint      = Id -> Id
zapJoinId Id
id

{-
************************************************************************
*                                                                      *
\subsection{IdInfo stuff}
*                                                                      *
************************************************************************
-}

        ---------------------------------
        -- ARITY
idArity :: Id -> Arity
idArity :: Id -> Arity
idArity Id
id = IdInfo -> Arity
arityInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdArity :: Id -> Arity -> Id
setIdArity :: Id -> Arity -> Id
setIdArity Id
id Arity
arity = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> Arity -> IdInfo
`setArityInfo` Arity
arity) Id
id

idCallArity :: Id -> Arity
idCallArity :: Id -> Arity
idCallArity Id
id = IdInfo -> Arity
callArityInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdCallArity :: Id -> Arity -> Id
setIdCallArity :: Id -> Arity -> Id
setIdCallArity Id
id Arity
arity = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> Arity -> IdInfo
`setCallArityInfo` Arity
arity) Id
id

-- | This function counts all arguments post-unarisation, which includes
-- arguments with no runtime representation -- see Note [Unarisation and arity]
idFunRepArity :: Id -> RepArity
idFunRepArity :: Id -> Arity
idFunRepArity Id
x = Arity -> Kind -> Arity
countFunRepArgs (Id -> Arity
idArity Id
x) (Id -> Kind
idType Id
x)

-- | Returns true if an application to n args diverges or throws an exception
-- See Note [Dead ends] in "GHC.Types.Demand".
isDeadEndId :: Var -> Bool
isDeadEndId :: Id -> Bool
isDeadEndId Id
v
  | Id -> Bool
isId Id
v    = DmdSig -> Bool
isDeadEndSig (Id -> DmdSig
idDmdSig Id
v)
  | Bool
otherwise = Bool
False

-- | Accesses the 'Id''s 'dmdSigInfo'.
idDmdSig :: Id -> DmdSig
idDmdSig :: Id -> DmdSig
idDmdSig Id
id = IdInfo -> DmdSig
dmdSigInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdDmdSig :: Id -> DmdSig -> Id
setIdDmdSig :: Id -> DmdSig -> Id
setIdDmdSig Id
id DmdSig
sig = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> DmdSig -> IdInfo
`setDmdSigInfo` DmdSig
sig) Id
id

idCprSig :: Id -> CprSig
idCprSig :: Id -> CprSig
idCprSig Id
id = IdInfo -> CprSig
cprSigInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdCprSig :: Id -> CprSig -> Id
setIdCprSig :: Id -> CprSig -> Id
setIdCprSig Id
id CprSig
sig = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (\IdInfo
info -> IdInfo -> CprSig -> IdInfo
setCprSigInfo IdInfo
info CprSig
sig) Id
id

zapIdDmdSig :: Id -> Id
zapIdDmdSig :: Id -> Id
zapIdDmdSig Id
id = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> DmdSig -> IdInfo
`setDmdSigInfo` DmdSig
nopSig) Id
id

-- | `isStrictId` says whether either
--   (a) the 'Id' has a strict demand placed on it or
--   (b) definitely has a \"strict type\", such that it can always be
--       evaluated strictly (i.e an unlifted type)
-- We need to check (b) as well as (a), because when the demand for the
-- given `id` hasn't been computed yet but `id` has a strict
-- type, we still want `isStrictId id` to be `True`.
-- Returns False if the type is levity polymorphic; False is always safe.
isStrictId :: Id -> Bool
isStrictId :: Id -> Bool
isStrictId Id
id
  | Bool -> SDoc -> Bool -> Bool
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Id -> Bool
isId Id
id) (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"isStrictId: not an id: " SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id) (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$
    Id -> Bool
isJoinId Id
id = Bool
False
  | Bool
otherwise   = HasDebugCallStack => Kind -> Bool
Kind -> Bool
isStrictType (Id -> Kind
idType Id
id) Bool -> Bool -> Bool
||
                  Demand -> Bool
isStrUsedDmd (Id -> Demand
idDemandInfo Id
id)
                  -- Take the best of both strictnesses - old and new

idTagSig_maybe :: Id -> Maybe TagSig
idTagSig_maybe :: Id -> Maybe TagSig
idTagSig_maybe = IdInfo -> Maybe TagSig
tagSig (IdInfo -> Maybe TagSig) -> (Id -> IdInfo) -> Id -> Maybe TagSig
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo

---------------------------------
-- UNFOLDING

-- | Returns the 'Id's unfolding, but does not expose the unfolding of a strong
-- loop breaker. See 'unfoldingInfo'.
--
-- If you really want the unfolding of a strong loopbreaker, call 'realIdUnfolding'.
idUnfolding :: IdUnfoldingFun
idUnfolding :: Id -> Unfolding
idUnfolding Id
id = IdInfo -> Unfolding
unfoldingInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

noUnfoldingFun :: IdUnfoldingFun
noUnfoldingFun :: Id -> Unfolding
noUnfoldingFun Id
_id = Unfolding
noUnfolding

-- | Returns an unfolding only if
--   (a) not a strong loop breaker and
--   (b) always active
alwaysActiveUnfoldingFun :: IdUnfoldingFun
alwaysActiveUnfoldingFun :: Id -> Unfolding
alwaysActiveUnfoldingFun Id
id
  | Activation -> Bool
isAlwaysActive (Id -> Activation
idInlineActivation Id
id) = Id -> Unfolding
idUnfolding Id
id
  | Bool
otherwise                              = Unfolding
noUnfolding

-- | Returns an unfolding only if
--   (a) not a strong loop breaker and
--   (b) active in according to is_active
whenActiveUnfoldingFun :: (Activation -> Bool) -> IdUnfoldingFun
whenActiveUnfoldingFun :: (Activation -> Bool) -> Id -> Unfolding
whenActiveUnfoldingFun Activation -> Bool
is_active Id
id
  | Activation -> Bool
is_active (Id -> Activation
idInlineActivation Id
id) = Id -> Unfolding
idUnfolding Id
id
  | Bool
otherwise                         = Unfolding
NoUnfolding

realIdUnfolding :: Id -> Unfolding
-- ^ Expose the unfolding if there is one, including for loop breakers
realIdUnfolding :: Id -> Unfolding
realIdUnfolding Id
id = IdInfo -> Unfolding
realUnfoldingInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdUnfolding :: Id -> Unfolding -> Id
setIdUnfolding :: Id -> Unfolding -> Id
setIdUnfolding Id
id Unfolding
unfolding = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> Unfolding -> IdInfo
`setUnfoldingInfo` Unfolding
unfolding) Id
id

idDemandInfo       :: Id -> Demand
idDemandInfo :: Id -> Demand
idDemandInfo       Id
id = IdInfo -> Demand
demandInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdDemandInfo :: Id -> Demand -> Id
setIdDemandInfo :: Id -> Demand -> Id
setIdDemandInfo Id
id Demand
dmd = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> Demand -> IdInfo
`setDemandInfo` Demand
dmd) Id
id

setIdTagSig :: Id -> TagSig -> Id
setIdTagSig :: Id -> TagSig -> Id
setIdTagSig Id
id TagSig
sig = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> TagSig -> IdInfo
`setTagSig` TagSig
sig) Id
id

-- | If all marks are NotMarkedStrict we just set nothing.
setIdCbvMarks :: Id -> [CbvMark] -> Id
setIdCbvMarks :: Id -> [CbvMark] -> Id
setIdCbvMarks Id
id [CbvMark]
marks
  | Bool -> Bool
not ((CbvMark -> Bool) -> [CbvMark] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CbvMark -> Bool
isMarkedCbv [CbvMark]
marks) = Id
id
  | Bool
otherwise =
      -- pprTrace "setMarks:" (ppr id <> text ":" <> ppr marks) $
      case Id -> IdDetails
idDetails Id
id of
        -- good ol (likely worker) function
        IdDetails
VanillaId ->      Id
id Id -> IdDetails -> Id
`setIdDetails` ([CbvMark] -> IdDetails
WorkerLikeId [CbvMark]
trimmedMarks)
        JoinId Arity
arity Maybe [CbvMark]
_ -> Id
id Id -> IdDetails -> Id
`setIdDetails` (Arity -> Maybe [CbvMark] -> IdDetails
JoinId Arity
arity ([CbvMark] -> Maybe [CbvMark]
forall a. a -> Maybe a
Just [CbvMark]
trimmedMarks))
        -- Updating an existing call by value function.
        WorkerLikeId [CbvMark]
_ -> Id
id Id -> IdDetails -> Id
`setIdDetails` ([CbvMark] -> IdDetails
WorkerLikeId [CbvMark]
trimmedMarks)
        -- Do nothing for these
        RecSelId{} -> Id
id
        DFunId{} -> Id
id
        IdDetails
_ -> String -> SDoc -> Id -> Id
forall a. String -> SDoc -> a -> a
pprTrace String
"setIdCbvMarks: Unable to set cbv marks for" (Id -> SDoc
forall a. Outputable a => a -> SDoc
ppr Id
id SDoc -> SDoc -> SDoc
forall doc. IsDoc doc => doc -> doc -> doc
$$
              String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"marks:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> [CbvMark] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [CbvMark]
marks SDoc -> SDoc -> SDoc
forall doc. IsDoc doc => doc -> doc -> doc
$$
              String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"idDetails:" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> IdDetails -> SDoc
forall a. Outputable a => a -> SDoc
ppr (Id -> IdDetails
idDetails Id
id)) Id
id

    where
      -- (Currently) no point in passing args beyond the arity unlifted.
      -- We would have to eta expand all call sites to (length marks).
      -- Perhaps that's sensible but for now be conservative.
      -- Similarly we don't need any lazy marks at the end of the list.
      -- This way the length of the list is always exactly number of arguments
      -- that must be visible to CodeGen. See See Note [CBV Function Ids]
      -- for more details.
      trimmedMarks :: [CbvMark]
trimmedMarks = (CbvMark -> Bool) -> [CbvMark] -> [CbvMark]
forall a. (a -> Bool) -> [a] -> [a]
dropWhileEndLE (Bool -> Bool
not (Bool -> Bool) -> (CbvMark -> Bool) -> CbvMark -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CbvMark -> Bool
isMarkedCbv) ([CbvMark] -> [CbvMark]) -> [CbvMark] -> [CbvMark]
forall a b. (a -> b) -> a -> b
$ Arity -> [CbvMark] -> [CbvMark]
forall a. Arity -> [a] -> [a]
take (Id -> Arity
idArity Id
id) [CbvMark]
marks

idCbvMarks_maybe :: Id -> Maybe [CbvMark]
idCbvMarks_maybe :: Id -> Maybe [CbvMark]
idCbvMarks_maybe Id
id = case Id -> IdDetails
idDetails Id
id of
  WorkerLikeId [CbvMark]
marks -> [CbvMark] -> Maybe [CbvMark]
forall a. a -> Maybe a
Just [CbvMark]
marks
  JoinId Arity
_arity Maybe [CbvMark]
marks  -> Maybe [CbvMark]
marks
  IdDetails
_                    -> Maybe [CbvMark]
forall a. Maybe a
Nothing

-- Id must be called with at least this arity in order to allow arguments to
-- be passed unlifted.
idCbvMarkArity :: Id -> Arity
idCbvMarkArity :: Id -> Arity
idCbvMarkArity Id
fn = Arity -> ([CbvMark] -> Arity) -> Maybe [CbvMark] -> Arity
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Arity
0 [CbvMark] -> Arity
forall a. [a] -> Arity
forall (t :: * -> *) a. Foldable t => t a -> Arity
length (Id -> Maybe [CbvMark]
idCbvMarks_maybe Id
fn)

-- | Remove any cbv marks on arguments from a given Id.
asNonWorkerLikeId :: Id -> Id
asNonWorkerLikeId :: Id -> Id
asNonWorkerLikeId Id
id =
  let details :: Maybe IdDetails
details = case Id -> IdDetails
idDetails Id
id of
        WorkerLikeId{}      -> IdDetails -> Maybe IdDetails
forall a. a -> Maybe a
Just (IdDetails -> Maybe IdDetails) -> IdDetails -> Maybe IdDetails
forall a b. (a -> b) -> a -> b
$ IdDetails
VanillaId
        JoinId Arity
arity Just{} -> IdDetails -> Maybe IdDetails
forall a. a -> Maybe a
Just (IdDetails -> Maybe IdDetails) -> IdDetails -> Maybe IdDetails
forall a b. (a -> b) -> a -> b
$ Arity -> Maybe [CbvMark] -> IdDetails
JoinId Arity
arity Maybe [CbvMark]
forall a. Maybe a
Nothing
        IdDetails
_                   -> Maybe IdDetails
forall a. Maybe a
Nothing
  in Maybe IdDetails -> Id -> Id
maybeModifyIdDetails Maybe IdDetails
details Id
id

-- | Turn this id into a WorkerLikeId if possible.
asWorkerLikeId :: Id -> Id
asWorkerLikeId :: Id -> Id
asWorkerLikeId Id
id =
  let details :: Maybe IdDetails
details = case Id -> IdDetails
idDetails Id
id of
        WorkerLikeId{}        -> Maybe IdDetails
forall a. Maybe a
Nothing
        JoinId Arity
_arity Just{}  -> Maybe IdDetails
forall a. Maybe a
Nothing
        JoinId Arity
arity Maybe [CbvMark]
Nothing  -> IdDetails -> Maybe IdDetails
forall a. a -> Maybe a
Just (Arity -> Maybe [CbvMark] -> IdDetails
JoinId Arity
arity ([CbvMark] -> Maybe [CbvMark]
forall a. a -> Maybe a
Just []))
        IdDetails
VanillaId             -> IdDetails -> Maybe IdDetails
forall a. a -> Maybe a
Just (IdDetails -> Maybe IdDetails) -> IdDetails -> Maybe IdDetails
forall a b. (a -> b) -> a -> b
$ [CbvMark] -> IdDetails
WorkerLikeId []
        IdDetails
_                     -> Maybe IdDetails
forall a. Maybe a
Nothing
  in Maybe IdDetails -> Id -> Id
maybeModifyIdDetails Maybe IdDetails
details Id
id

setCaseBndrEvald :: StrictnessMark -> Id -> Id
-- Used for variables bound by a case expressions, both the case-binder
-- itself, and any pattern-bound variables that are argument of a
-- strict constructor.  It just marks the variable as already-evaluated,
-- so that (for example) a subsequent 'seq' can be dropped
setCaseBndrEvald :: StrictnessMark -> Id -> Id
setCaseBndrEvald StrictnessMark
str Id
id
  | StrictnessMark -> Bool
isMarkedStrict StrictnessMark
str = Id
id Id -> Unfolding -> Id
`setIdUnfolding` Unfolding
evaldUnfolding
  | Bool
otherwise          = Id
id

-- | Similar to trimUnfolding, but also removes evaldness info.
zapIdUnfolding :: Id -> Id
zapIdUnfolding :: Id -> Id
zapIdUnfolding Id
v
  | Id -> Bool
isId Id
v, Unfolding -> Bool
hasSomeUnfolding (Id -> Unfolding
idUnfolding Id
v) = Id -> Unfolding -> Id
setIdUnfolding Id
v Unfolding
noUnfolding
  | Bool
otherwise = Id
v

        ---------------------------------
        -- SPECIALISATION

-- See Note [Specialisations and RULES in IdInfo] in GHC.Types.Id.Info

idSpecialisation :: Id -> RuleInfo
idSpecialisation :: Id -> RuleInfo
idSpecialisation Id
id = IdInfo -> RuleInfo
ruleInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

idCoreRules :: Id -> [CoreRule]
idCoreRules :: Id -> [CoreRule]
idCoreRules Id
id = RuleInfo -> [CoreRule]
ruleInfoRules (Id -> RuleInfo
idSpecialisation Id
id)

idHasRules :: Id -> Bool
idHasRules :: Id -> Bool
idHasRules Id
id = Bool -> Bool
not (RuleInfo -> Bool
isEmptyRuleInfo (Id -> RuleInfo
idSpecialisation Id
id))

setIdSpecialisation :: Id -> RuleInfo -> Id
setIdSpecialisation :: Id -> RuleInfo -> Id
setIdSpecialisation Id
id RuleInfo
spec_info = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> RuleInfo -> IdInfo
`setRuleInfo` RuleInfo
spec_info) Id
id

        ---------------------------------
        -- CAF INFO
idCafInfo :: Id -> CafInfo
idCafInfo :: Id -> CafInfo
idCafInfo Id
id = IdInfo -> CafInfo
cafInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdCafInfo :: Id -> CafInfo -> Id
setIdCafInfo :: Id -> CafInfo -> Id
setIdCafInfo Id
id CafInfo
caf_info = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> CafInfo -> IdInfo
`setCafInfo` CafInfo
caf_info) Id
id

        ---------------------------------
        -- Lambda form info

idLFInfo_maybe :: Id -> Maybe LambdaFormInfo
idLFInfo_maybe :: Id -> Maybe LambdaFormInfo
idLFInfo_maybe = IdInfo -> Maybe LambdaFormInfo
lfInfo (IdInfo -> Maybe LambdaFormInfo)
-> (Id -> IdInfo) -> Id -> Maybe LambdaFormInfo
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo

setIdLFInfo :: Id -> LambdaFormInfo -> Id
setIdLFInfo :: Id -> LambdaFormInfo -> Id
setIdLFInfo Id
id LambdaFormInfo
lf = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> LambdaFormInfo -> IdInfo
`setLFInfo` LambdaFormInfo
lf) Id
id

        ---------------------------------
        -- Occurrence INFO
idOccInfo :: Id -> OccInfo
idOccInfo :: Id -> OccInfo
idOccInfo Id
id = IdInfo -> OccInfo
occInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setIdOccInfo :: Id -> OccInfo -> Id
setIdOccInfo :: Id -> OccInfo -> Id
setIdOccInfo Id
id OccInfo
occ_info = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> OccInfo -> IdInfo
`setOccInfo` OccInfo
occ_info) Id
id

zapIdOccInfo :: Id -> Id
zapIdOccInfo :: Id -> Id
zapIdOccInfo Id
b = Id
b Id -> OccInfo -> Id
`setIdOccInfo` OccInfo
noOccInfo

{-
        ---------------------------------
        -- INLINING
The inline pragma tells us to be very keen to inline this Id, but it's still
OK not to if optimisation is switched off.
-}

idInlinePragma :: Id -> InlinePragma
idInlinePragma :: Id -> InlinePragma
idInlinePragma Id
id = IdInfo -> InlinePragma
inlinePragInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setInlinePragma :: Id -> InlinePragma -> Id
setInlinePragma :: Id -> InlinePragma -> Id
setInlinePragma Id
id InlinePragma
prag = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> InlinePragma -> IdInfo
`setInlinePragInfo` InlinePragma
prag) Id
id

modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
modifyInlinePragma :: Id -> (InlinePragma -> InlinePragma) -> Id
modifyInlinePragma Id
id InlinePragma -> InlinePragma
fn = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (\IdInfo
info -> IdInfo
info IdInfo -> InlinePragma -> IdInfo
`setInlinePragInfo` (InlinePragma -> InlinePragma
fn (IdInfo -> InlinePragma
inlinePragInfo IdInfo
info))) Id
id

idInlineActivation :: Id -> Activation
idInlineActivation :: Id -> Activation
idInlineActivation Id
id = InlinePragma -> Activation
inlinePragmaActivation (Id -> InlinePragma
idInlinePragma Id
id)

setInlineActivation :: Id -> Activation -> Id
setInlineActivation :: Id -> Activation -> Id
setInlineActivation Id
id Activation
act = Id -> (InlinePragma -> InlinePragma) -> Id
modifyInlinePragma Id
id (\InlinePragma
prag -> InlinePragma -> Activation -> InlinePragma
setInlinePragmaActivation InlinePragma
prag Activation
act)

idRuleMatchInfo :: Id -> RuleMatchInfo
idRuleMatchInfo :: Id -> RuleMatchInfo
idRuleMatchInfo Id
id = InlinePragma -> RuleMatchInfo
inlinePragmaRuleMatchInfo (Id -> InlinePragma
idInlinePragma Id
id)

isConLikeId :: Id -> Bool
isConLikeId :: Id -> Bool
isConLikeId Id
id = RuleMatchInfo -> Bool
isConLike (Id -> RuleMatchInfo
idRuleMatchInfo Id
id)

{-
        ---------------------------------
        -- ONE-SHOT LAMBDAS
-}

idOneShotInfo :: Id -> OneShotInfo
idOneShotInfo :: Id -> OneShotInfo
idOneShotInfo Id
id = IdInfo -> OneShotInfo
oneShotInfo (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)

setOneShotLambda :: Id -> Id
setOneShotLambda :: Id -> Id
setOneShotLambda Id
id = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> OneShotInfo -> IdInfo
`setOneShotInfo` OneShotInfo
OneShotLam) Id
id

clearOneShotLambda :: Id -> Id
clearOneShotLambda :: Id -> Id
clearOneShotLambda Id
id = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> OneShotInfo -> IdInfo
`setOneShotInfo` OneShotInfo
NoOneShotInfo) Id
id

setIdOneShotInfo :: Id -> OneShotInfo -> Id
setIdOneShotInfo :: Id -> OneShotInfo -> Id
setIdOneShotInfo Id
id OneShotInfo
one_shot = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo (IdInfo -> OneShotInfo -> IdInfo
`setOneShotInfo` OneShotInfo
one_shot) Id
id

updOneShotInfo :: Id -> OneShotInfo -> Id
-- Combine the info in the Id with new info
updOneShotInfo :: Id -> OneShotInfo -> Id
updOneShotInfo Id
id OneShotInfo
one_shot
  | Bool
do_upd    = Id -> OneShotInfo -> Id
setIdOneShotInfo Id
id OneShotInfo
one_shot
  | Bool
otherwise = Id
id
  where
    do_upd :: Bool
do_upd = case (Id -> OneShotInfo
idOneShotInfo Id
id, OneShotInfo
one_shot) of
                (OneShotInfo
NoOneShotInfo, OneShotInfo
_) -> Bool
True
                (OneShotInfo
OneShotLam,    OneShotInfo
_) -> Bool
False

-- The OneShotLambda functions simply fiddle with the IdInfo flag
-- But watch out: this may change the type of something else
--      f = \x -> e
-- If we change the one-shot-ness of x, f's type changes

-- Replaces the id info if the zapper returns @Just idinfo@
zapInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapper Id
id = Maybe IdInfo -> Id -> Id
maybeModifyIdInfo (IdInfo -> Maybe IdInfo
zapper (HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
id)) Id
id

zapLamIdInfo :: Id -> Id
zapLamIdInfo :: Id -> Id
zapLamIdInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapLamInfo

zapFragileIdInfo :: Id -> Id
zapFragileIdInfo :: Id -> Id
zapFragileIdInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapFragileInfo

zapIdDemandInfo :: Id -> Id
zapIdDemandInfo :: Id -> Id
zapIdDemandInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapDemandInfo

zapIdUsageInfo :: Id -> Id
zapIdUsageInfo :: Id -> Id
zapIdUsageInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapUsageInfo

zapIdUsageEnvInfo :: Id -> Id
zapIdUsageEnvInfo :: Id -> Id
zapIdUsageEnvInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapUsageEnvInfo

zapIdUsedOnceInfo :: Id -> Id
zapIdUsedOnceInfo :: Id -> Id
zapIdUsedOnceInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapUsedOnceInfo

zapIdTailCallInfo :: Id -> Id
zapIdTailCallInfo :: Id -> Id
zapIdTailCallInfo = (IdInfo -> Maybe IdInfo) -> Id -> Id
zapInfo IdInfo -> Maybe IdInfo
zapTailCallInfo

zapStableUnfolding :: Id -> Id
zapStableUnfolding :: Id -> Id
zapStableUnfolding Id
id
 | Unfolding -> Bool
isStableUnfolding (Id -> Unfolding
realIdUnfolding Id
id) = Id -> Unfolding -> Id
setIdUnfolding Id
id Unfolding
NoUnfolding
 | Bool
otherwise                              = Id
id

{-
Note [transferPolyIdInfo]
~~~~~~~~~~~~~~~~~~~~~~~~~
This transfer is used in three places:
        FloatOut (long-distance let-floating)
        GHC.Core.Opt.Simplify.Utils.abstractFloats (short-distance let-floating)
        StgLiftLams (selectively lambda-lift local functions to top-level)

Consider the short-distance let-floating:

   f = /\a. let g = rhs in ...

Then if we float thus

   g' = /\a. rhs
   f = /\a. ...[g' a/g]....

we *do not* want to lose g's
  * strictness information
  * arity
  * inline pragma (though that is bit more debatable)
  * occurrence info

Mostly this is just an optimisation, but it's *vital* to
transfer the occurrence info.  Consider

   NonRec { f = /\a. let Rec { g* = ..g.. } in ... }

where the '*' means 'LoopBreaker'.  Then if we float we must get

   Rec { g'* = /\a. ...(g' a)... }
   NonRec { f = /\a. ...[g' a/g]....}

where g' is also marked as LoopBreaker.  If not, terrible things
can happen if we re-simplify the binding (and the Simplifier does
sometimes simplify a term twice); see #4345.

It's not so simple to retain
  * worker info
  * rules
so we simply discard those.  Sooner or later this may bite us.

If we abstract wrt one or more *value* binders, we must modify the
arity and strictness info before transferring it.  E.g.
      f = \x. e
-->
      g' = \y. \x. e
      + substitute (g' y) for g
Notice that g' has an arity one more than the original g
-}

transferPolyIdInfo :: Id        -- Original Id
                   -> [Var]     -- Abstract wrt these variables
                   -> Id        -- New Id
                   -> Id
transferPolyIdInfo :: Id -> [Id] -> Id -> Id
transferPolyIdInfo Id
old_id [Id]
abstract_wrt Id
new_id
  = HasDebugCallStack => (IdInfo -> IdInfo) -> Id -> Id
(IdInfo -> IdInfo) -> Id -> Id
modifyIdInfo IdInfo -> IdInfo
transfer Id
new_id Id -> [CbvMark] -> Id
`setIdCbvMarks` [CbvMark]
new_cbv_marks
  where
    arity_increase :: Arity
arity_increase = (Id -> Bool) -> [Id] -> Arity
forall a. (a -> Bool) -> [a] -> Arity
count Id -> Bool
isId [Id]
abstract_wrt    -- Arity increases by the
                                                -- number of value binders

    old_info :: IdInfo
old_info        = HasDebugCallStack => Id -> IdInfo
Id -> IdInfo
idInfo Id
old_id
    old_arity :: Arity
old_arity       = IdInfo -> Arity
arityInfo IdInfo
old_info
    old_inline_prag :: InlinePragma
old_inline_prag = IdInfo -> InlinePragma
inlinePragInfo IdInfo
old_info
    old_occ_info :: OccInfo
old_occ_info    = IdInfo -> OccInfo
occInfo IdInfo
old_info
    new_arity :: Arity
new_arity       = Arity
old_arity Arity -> Arity -> Arity
forall a. Num a => a -> a -> a
+ Arity
arity_increase
    new_occ_info :: OccInfo
new_occ_info    = OccInfo -> OccInfo
zapOccTailCallInfo OccInfo
old_occ_info

    old_strictness :: DmdSig
old_strictness  = IdInfo -> DmdSig
dmdSigInfo IdInfo
old_info
    new_strictness :: DmdSig
new_strictness  = Arity -> DmdSig -> DmdSig
prependArgsDmdSig Arity
arity_increase DmdSig
old_strictness
    old_cpr :: CprSig
old_cpr         = IdInfo -> CprSig
cprSigInfo IdInfo
old_info
    new_cpr :: CprSig
new_cpr         = Arity -> CprSig -> CprSig
prependArgsCprSig Arity
arity_increase CprSig
old_cpr

    old_cbv_marks :: [CbvMark]
old_cbv_marks   = [CbvMark] -> Maybe [CbvMark] -> [CbvMark]
forall a. a -> Maybe a -> a
fromMaybe (Arity -> CbvMark -> [CbvMark]
forall a. Arity -> a -> [a]
replicate Arity
old_arity CbvMark
NotMarkedCbv) (Id -> Maybe [CbvMark]
idCbvMarks_maybe Id
old_id)
    abstr_cbv_marks :: [CbvMark]
abstr_cbv_marks = (Id -> Maybe CbvMark) -> [Id] -> [CbvMark]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Id -> Maybe CbvMark
getMark [Id]
abstract_wrt
    new_cbv_marks :: [CbvMark]
new_cbv_marks   = [CbvMark]
abstr_cbv_marks [CbvMark] -> [CbvMark] -> [CbvMark]
forall a. [a] -> [a] -> [a]
++ [CbvMark]
old_cbv_marks

    getMark :: Id -> Maybe CbvMark
getMark Id
v
      | Bool -> Bool
not (Id -> Bool
isId Id
v)
      = Maybe CbvMark
forall a. Maybe a
Nothing
      | Id -> Bool
isId Id
v
      , Unfolding -> Bool
isEvaldUnfolding (Id -> Unfolding
idUnfolding Id
v)
      , Kind -> Bool
mightBeLiftedType (Id -> Kind
idType Id
v)
      = CbvMark -> Maybe CbvMark
forall a. a -> Maybe a
Just CbvMark
MarkedCbv
      | Bool
otherwise = CbvMark -> Maybe CbvMark
forall a. a -> Maybe a
Just CbvMark
NotMarkedCbv
    transfer :: IdInfo -> IdInfo
transfer IdInfo
new_info = IdInfo
new_info IdInfo -> Arity -> IdInfo
`setArityInfo`      Arity
new_arity
                                 IdInfo -> InlinePragma -> IdInfo
`setInlinePragInfo` InlinePragma
old_inline_prag
                                 IdInfo -> OccInfo -> IdInfo
`setOccInfo`        OccInfo
new_occ_info
                                 IdInfo -> DmdSig -> IdInfo
`setDmdSigInfo`     DmdSig
new_strictness
                                 IdInfo -> CprSig -> IdInfo
`setCprSigInfo`     CprSig
new_cpr