RecFlag(..), isRec, isNonRec, boolToRecFlag,
+ RuleName,
+
TopLevelFlag(..), isTopLevel, isNotTopLevel,
OverlapFlag(..),
ppr (IPName n) = char '?' <> ppr n -- Ordinary implicit parameters
\end{code}
+%************************************************************************
+%* *
+ Rules
+%* *
+%************************************************************************
+
+\begin{code}
+type RuleName = FastString
+\end{code}
%************************************************************************
%* *
\begin{code}
module Id (
+ -- * The main types
Id, DictId,
- -- Simple construction
- mkGlobalId, mkLocalId, mkLocalIdWithInfo,
- mkSysLocal, mkUserLocal, mkVanillaGlobal,
- mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
- mkWorkerId, mkExportedLocalId,
+ -- ** Simple construction
+ mkGlobalId, mkVanillaGlobal, mkVanillaGlobalWithInfo,
+ mkLocalId, mkLocalIdWithInfo,
+ mkSysLocal, mkSysLocalM, mkUserLocal, mkUserLocalM,
- -- Taking an Id apart
+ -- ** Taking an Id apart
idName, idType, idUnique, idInfo,
isId, globalIdDetails, idPrimRep,
recordSelectorFieldLabel,
- -- Modifying an Id
+ -- ** Modifying an Id
setIdName, setIdUnique, Id.setIdType, setIdExported, setIdNotExported,
- setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
+ globaliseId, setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
zapLamIdInfo, zapDemandIdInfo, zapFragileIdInfo, transferPolyIdInfo,
- -- Predicates
+ -- ** Predicates on Ids
isImplicitId, isDeadBinder, isDictId, isStrictId,
isExportedId, isLocalId, isGlobalId,
isRecordSelector, isNaughtyRecordSelector,
isTickBoxOp, isTickBoxOp_maybe,
hasNoBinding,
- -- Inline pragma stuff
+ -- ** Inline pragma stuff
idInlinePragma, setInlinePragma, modifyInlinePragma,
- -- One shot lambda stuff
+ -- ** One shot lambda stuff
isOneShotBndr, isOneShotLambda, isStateHackType,
setOneShotLambda, clearOneShotLambda,
- -- IdInfo stuff
+ -- ** IdInfo stuff
setIdUnfolding,
setIdArity,
setIdNewDemandInfo,
setIdCafInfo,
setIdOccInfo,
+ -- ** Id demand information
#ifdef OLD_STRICTNESS
idDemandInfo,
idStrictness,
#include "HsVersions.h"
-import CoreSyn
+import {-# SOURCE #-} CoreSyn ( CoreRule, Unfolding )
+
+import IdInfo
import BasicTypes
import qualified Var
-import Var hiding (mkLocalId, mkGlobalId, mkExportedLocalId)
+import Var
import TyCon
import Type
import TcType
-import TysPrim
-import IdInfo
+import TysPrim
#ifdef OLD_STRICTNESS
import qualified Demand
#endif
import SrcLoc
import Outputable
import Unique
+import UniqSupply
import FastString
import StaticFlags
,`setIdDemandInfo`
#endif
\end{code}
+%************************************************************************
+%* *
+\subsection{Basic Id manipulation}
+%* *
+%************************************************************************
+
+\begin{code}
+idName :: Id -> Name
+idName = Var.varName
+
+idUnique :: Id -> Unique
+idUnique = varUnique
+
+idType :: Id -> Kind
+idType = varType
+
+setIdUnique :: Id -> Unique -> Id
+setIdUnique = setVarUnique
+
+setIdName :: Id -> Name -> Id
+setIdName = setVarName
+
+setIdType :: Id -> Type -> Id
+setIdType id ty = seqType ty `seq` Var.setVarType id ty
+setIdExported :: Id -> Id
+setIdExported = setIdVarExported
+setIdNotExported :: Id -> Id
+setIdNotExported = setIdVarNotExported
+
+globaliseId :: GlobalIdDetails -> Id -> Id
+globaliseId = globaliseIdVar
+
+idInfo :: Id -> IdInfo
+idInfo = varIdInfo
+
+lazySetIdInfo :: Id -> IdInfo -> Id
+lazySetIdInfo = lazySetVarIdInfo
+
+setIdInfo :: Id -> IdInfo -> Id
+setIdInfo id info = seqIdInfo info `seq` (lazySetIdInfo id info)
+ -- Try to avoid spack leaks by seq'ing
+
+modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
+modifyIdInfo fn id = setIdInfo id (fn (idInfo id))
+
+-- maybeModifyIdInfo tries to avoid unnecesary thrashing
+maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
+maybeModifyIdInfo (Just new_info) id = lazySetIdInfo id new_info
+maybeModifyIdInfo Nothing id = id
+\end{code}
%************************************************************************
%* *
Anyway, we removed it in March 2008.
\begin{code}
-mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
-mkLocalIdWithInfo name ty info = Var.mkLocalId name ty info
- -- Note [Free type variables]
+-- | Create a global Id. Global identifiers are those that are imported or are data constructors/destructors.
+mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
+mkGlobalId = mkGlobalIdVar
-mkExportedLocalId :: Name -> Type -> Id
-mkExportedLocalId name ty = Var.mkExportedLocalId name ty vanillaIdInfo
- -- Note [Free type variables]
+mkVanillaGlobal :: Name -> Type -> Id
+mkVanillaGlobal name ty = mkVanillaGlobalWithInfo name ty vanillaIdInfo
-mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
-mkGlobalId details name ty info = Var.mkGlobalId details name ty info
-\end{code}
+mkVanillaGlobalWithInfo :: Name -> Type -> IdInfo -> Id
+mkVanillaGlobalWithInfo = mkGlobalId VanillaGlobal
-\begin{code}
+
+-- | Create a local Id. Local identifiers are those bound at the top level of the current module or in an expression.
mkLocalId :: Name -> Type -> Id
mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
--- SysLocal: for an Id being created by the compiler out of thin air...
+mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
+mkLocalIdWithInfo = mkLocalIdVar
+
+-- | Create a local Id that is marked as exported. This prevents things attached to it from being removed as dead code.
+mkExportedLocalId :: Name -> Type -> Id
+mkExportedLocalId name ty = mkExportedLocalIdVar name ty vanillaIdInfo
+ -- Note [Free type variables]
+
+
+-- | Create a system local Id. These are local Ids that are created by the compiler out of thin air
mkSysLocal :: FastString -> Unique -> Type -> Id
mkSysLocal fs uniq ty = mkLocalId (mkSystemVarName uniq fs) ty
+mkSysLocalM :: MonadUnique m => FastString -> Type -> m Id
+mkSysLocalM fs ty = getUniqueM >>= (\uniq -> return (mkSysLocal fs uniq ty))
+
--- UserLocal: an Id with a name the user might recognize...
+-- | Create a user local Id. These are local Id with a name and location that the user might recognize
mkUserLocal :: OccName -> Unique -> Type -> SrcSpan -> Id
-mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
+mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
-mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
-mkVanillaGlobal = mkGlobalId VanillaGlobal
+mkUserLocalM :: MonadUnique m => OccName -> Type -> SrcSpan -> m Id
+mkUserLocalM occ ty loc = getUniqueM >>= (\uniq -> return (mkUserLocal occ uniq ty loc))
\end{code}
Make some local @Ids@ for a template @CoreExpr@. These have bogus
instantiated before use.
\begin{code}
--- "Wild Id" typically used when you need a binder that you don't expect to use
+-- | Make a "wild Id". This is typically used when you need a binder that you don't expect to use
mkWildId :: Type -> Id
mkWildId ty = mkSysLocal (fsLit "wild") (mkBuiltinUnique 1) ty
mkWorkerId :: Unique -> Id -> Type -> Id
--- A worker gets a local name. CoreTidy will externalise it if necessary.
+-- | Workers get local names. CoreTidy will externalise these if necessary
mkWorkerId uniq unwrkr ty
= mkLocalId wkr_name ty
where
wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcSpan unwrkr)
--- "Template locals" typically used in unfoldings
+-- | Create a "template local": a family of system local Ids in bijection with Ints, typically used in unfoldings
+mkTemplateLocal :: Int -> Type -> Id
+mkTemplateLocal i ty = mkSysLocal (fsLit "tpl") (mkBuiltinUnique i) ty
+
+-- | Create a template local for a series of types
mkTemplateLocals :: [Type] -> [Id]
-mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
+mkTemplateLocals = mkTemplateLocalsNum 1
+-- | Create a template local for a series of type, but start from a specified template local
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
-- The Int gives the starting point for unique allocation
mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
-
-mkTemplateLocal :: Int -> Type -> Id
-mkTemplateLocal i ty = mkSysLocal (fsLit "tpl") (mkBuiltinUnique i) ty
\end{code}
%************************************************************************
\begin{code}
-setIdType :: Id -> Type -> Id
- -- Add free tyvar info to the type
-setIdType id ty = seqType ty `seq` Var.setIdType id ty
-
idPrimRep :: Id -> PrimRep
idPrimRep id = typePrimRep (idType id)
+
+globalIdDetails :: Id -> GlobalIdDetails
+globalIdDetails = globalIdVarDetails
+
+isId :: Id -> Bool
+isId = isIdVar
+
+isLocalId :: Id -> Bool
+isLocalId = isLocalIdVar
+
+isGlobalId :: Id -> Bool
+isGlobalId = isGlobalIdVar
+
+isExportedId :: Var -> Bool
+isExportedId = isExportedIdVar
\end{code}
RecordSelId { sel_tycon = tycon, sel_label = lbl } -> (tycon,lbl)
_ -> panic "recordSelectorFieldLabel"
-isRecordSelector :: Var -> Bool
-isNaughtyRecordSelector :: Var -> Bool
-isPrimOpId :: Var -> Bool
-isFCallId :: Var -> Bool
-isDataConWorkId :: Var -> Bool
-hasNoBinding :: Var -> Bool
+isRecordSelector :: Id -> Bool
+isNaughtyRecordSelector :: Id -> Bool
+isPrimOpId :: Id -> Bool
+isFCallId :: Id -> Bool
+isDataConWorkId :: Id -> Bool
-isClassOpId_maybe :: Var -> Maybe Class
-isPrimOpId_maybe :: Var -> Maybe PrimOp
-isFCallId_maybe :: Var -> Maybe ForeignCall
-isDataConWorkId_maybe :: Var -> Maybe DataCon
+isClassOpId_maybe :: Id -> Maybe Class
+isPrimOpId_maybe :: Id -> Maybe PrimOp
+isFCallId_maybe :: Id -> Maybe ForeignCall
+isDataConWorkId_maybe :: Id -> Maybe DataCon
isRecordSelector id = case globalIdDetails id of
RecordSelId {} -> True
_ -> Nothing
idDataCon :: Id -> DataCon
--- Get from either the worker or the wrapper to the DataCon
--- Currently used only in the desugarer
--- INVARIANT: idDataCon (dataConWrapId d) = d
+-- ^ Get from either the worker or the wrapper 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 = case globalIdDetails id of
- DataConWorkId con -> con
- DataConWrapId con -> con
- _ -> pprPanic "idDataCon" (ppr id)
+idDataCon id = isDataConId_maybe id `orElse` pprPanic "idDataCon" (ppr id
isDictId :: Id -> Bool
isDictId id = isDictTy (idType id)
--- hasNoBinding returns True of an Id which may not have a
+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
_ -> False
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 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
= case globalIdDetails id of
RecordSelId {} -> True
setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
#endif
--- isBottomingId returns true if an application to n args would diverge
+-- | Returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
isBottomingId id = isBottomingSig (idNewStrictness id)
zapIdNewStrictness :: Id -> Id
zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
-\end{code}
-This predicate says whether the id has a strict demand placed on it or
-has a type such that it can always be evaluated strictly (e.g., an
-unlifted type, but see the comment for isStrictType). We need to
-check separately whether <id> has a so-called "strict type" because if
-the demand for <id> hasn't been computed yet but <id> has a strict
-type, we still want (isStrictId <id>) to be True.
-\begin{code}
+-- | This predicate says whether the id has a strict demand placed on it or
+-- has a type such that it can always be evaluated strictly (e.g., an
+-- unlifted type, but see the comment for 'isStrictType'). We need to
+-- check separately whether <id> has a so-called "strict type" because if
+-- the demand for <id> hasn't been computed yet but <id> has a strict
+-- type, we still want @isStrictId <id>@ to be True.
isStrictId :: Id -> Bool
isStrictId id
= ASSERT2( isId id, text "isStrictId: not an id: " <+> ppr id )
TickBoxOp(..), TickBoxId,
) where
-import CoreSyn
import Class
import PrimOp
import Name
setSpecInfoHead :: Name -> SpecInfo -> SpecInfo
setSpecInfoHead fn (SpecInfo rules fvs)
- = SpecInfo (map set_head rules) fvs
- where
- set_head rule = rule { ru_fn = fn }
+ = SpecInfo (map (setRuleIdName fn) rules) fvs
seqSpecInfo :: SpecInfo -> ()
seqSpecInfo (SpecInfo rules fvs) = seqRules rules `seq` seqVarSet fvs
zapFragileInfo info
= Just (info `setSpecInfo` emptySpecInfo
`setWorkerInfo` NoWorker
- `setUnfoldingInfo` NoUnfolding
+ `setUnfoldingInfo` noUnfolding
`setOccInfo` if isFragileOcc occ then NoOccInfo else occ)
where
occ = occInfo info
\begin{code}
pcMiscPrelId :: Name -> Type -> IdInfo -> Id
pcMiscPrelId name ty info
- = mkVanillaGlobal name ty info
+ = mkVanillaGlobalWithInfo name ty info
-- We lie and say the thing is imported; otherwise, we get into
-- a mess with dependency analysis; e.g., core2stg may heave in
-- random calls to GHCbase.unpackPS__. If GHCbase is the module
\section{@Vars@: Variables}
\begin{code}
+-- |
+-- #name_types#
+-- GHC uses several kinds of name internally:
+--
+-- * 'OccName.OccName': see "OccName#name_types"
+--
+-- * 'RdrName.RdrName': see "RdrName#name_types"
+--
+-- * 'Name.Name': see "Name#name_types"
+--
+-- * 'Id.Id': see "Id#name_types"
+--
+-- * 'Var.Var' is a synonym for the 'Id.Id' type but it may additionally potentially contain type variables,
+-- which have a 'TypeRep.Kind' rather than a 'TypeRep.Type' and only contain some extra details during typechecking.
+-- These 'Var.Var' names may either be global or local, see "Var#globalvslocal"
+--
+-- #globalvslocal#
+-- Global 'Id's and 'Var's are those that are imported or correspond to a data constructor, primitive operation, or record selectors.
+-- Local 'Id's and 'Var's are those bound within an expression (e.g. by a lambda) or at the top level of the module being compiled.
module Var (
- Var,
- varName, varUnique, varType,
- setVarName, setVarUnique,
+ -- * The main data type
+ Var,
- -- TyVars
- TyVar, mkTyVar, mkTcTyVar, mkWildCoVar,
- tyVarName, tyVarKind,
+ -- ** Constructing 'Var's
+ mkLocalIdVar, mkExportedLocalIdVar, mkGlobalIdVar,
+
+ -- ** Taking 'Var's apart
+ varName, varUnique, varType, varIdInfo, globalIdVarDetails,
+
+ -- ** Modifying 'Var's
+ setVarName, setVarUnique, setVarType,
+ setIdVarExported, setIdVarNotExported,
+ globaliseIdVar, lazySetVarIdInfo,
+
+ -- ** Predicates
+ isCoVar, isIdVar, isTyVar, isTcTyVar,
+ isLocalVar, isLocalIdVar,
+ isGlobalIdVar, isExportedIdVar,
+ mustHaveLocalBinding,
+
+ -- * Type variable data type
+ TyVar,
+
+ -- ** Constructing 'TyVar's
+ mkTyVar, mkTcTyVar, mkWildCoVar,
+
+ -- ** Taking 'TyVar's apart
+ tyVarName, tyVarKind, tcTyVarDetails,
+
+ -- ** Modifying 'TyVar's
setTyVarName, setTyVarUnique, setTyVarKind,
- tcTyVarDetails,
- -- CoVars
- CoVar, coVarName, setCoVarUnique, setCoVarName, mkCoVar, isCoVar,
+ -- * Coercion variable data type
+ CoVar,
- -- Ids
- Id, DictId,
- idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
- setIdName, setIdUnique, setIdType, setIdInfo, lazySetIdInfo,
- setIdExported, setIdNotExported,
+ -- ** Constructing 'CoVar's
+ mkCoVar,
- globalIdDetails, globaliseId,
+ -- ** Taking 'CoVar's apart
+ coVarName,
- mkLocalId, mkExportedLocalId, mkGlobalId,
+ -- ** Modifying 'CoVar's
+ setCoVarUnique, setCoVarName,
- isTyVar, isTcTyVar, isId, isLocalVar, isLocalId,
- isGlobalId, isExportedId,
- mustHaveLocalBinding
+ -- * 'Var' type synonyms
+ Id, DictId
) where
#include "HsVersions.h"
import {-# SOURCE #-} TypeRep( Type, Kind )
import {-# SOURCE #-} TcType( TcTyVarDetails, pprTcTyVarDetails )
import {-# SOURCE #-} IdInfo( GlobalIdDetails, notGlobalId,
- IdInfo, seqIdInfo )
+ IdInfo )
import {-# SOURCE #-} TypeRep( isCoercionKind )
import Name hiding (varName)
import Unique
import FastTypes
import FastString
-import Outputable
+import Outputable
\end{code}
in its @VarDetails@.
\begin{code}
+-- | Essentially a typed 'Name', that may also contain some additional information
+-- about the 'Var' and it's use sites.
data Var
= TyVar {
varName :: !Name,
realUnique :: FastInt, -- Key for fast comparison
-- Identical to the Unique in the name,
-- cached here for speed
- varType :: Kind,
+ varType :: Kind, -- ^ The type or kind of the 'Var' in question
isCoercionVar :: Bool
}
lclDetails :: LocalIdDetails }
data LocalIdDetails
- = NotExported -- Not exported
- | Exported -- Exported
- -- Exported Ids are kept alive;
- -- NotExported things may be discarded as dead code.
+ = NotExported -- ^ Not exported: may be discarded as dead code.
+ | Exported -- ^ Exported: kept alive
\end{code}
Note [GlobalId/LocalId]
* always treated as a candidate by the free-variable finder
After CoreTidy, top-level LocalIds are turned into GlobalIds
-
\begin{code}
instance Outputable Var where
setVarName var new_name
= var { realUnique = getKeyFastInt (getUnique new_name),
varName = new_name }
+
+setVarType :: Id -> Type -> Id
+setVarType id ty = id { varType = ty }
+
+setIdVarExported :: Var -> Var
+-- ^ Exports the given local 'Id'. Can also be called on global 'Id's, such as data constructors
+-- and class operations, which are born as global 'Id's and automatically exported
+setIdVarExported id@(LocalId {}) = id { lclDetails = Exported }
+setIdVarExported other_id = ASSERT( isIdVar other_id ) other_id
+
+setIdVarNotExported :: Id -> Id
+-- ^ We can only do this to LocalIds
+setIdVarNotExported id = ASSERT( isLocalIdVar id ) id { lclDetails = NotExported }
+
+globaliseIdVar :: GlobalIdDetails -> Var -> Var
+-- ^ If it's a local, make it global
+globaliseIdVar details id = GlobalId { varName = varName id,
+ realUnique = realUnique id,
+ varType = varType id,
+ idInfo_ = varIdInfo id,
+ gblDetails = details }
+
+-- | Extract 'Id' information from the 'Var' if it represents a global or local 'Id', otherwise panic
+varIdInfo :: Var -> IdInfo
+varIdInfo (GlobalId {idInfo_ = info}) = info
+varIdInfo (LocalId {idInfo_ = info}) = info
+varIdInfo other_var = pprPanic "idInfo" (ppr other_var)
+
+lazySetVarIdInfo :: Var -> IdInfo -> Var
+lazySetVarIdInfo id info = id { idInfo_ = info }
\end{code}
%************************************************************************
\begin{code}
-type CoVar = Var -- A coercion variable is simply a type
- -- variable of kind (ty1 :=: ty2)
+type CoVar = Var -- ^ A coercion variable is simply a type
+ -- variable of kind @ty1 :=: ty2@. Hence its
+ -- 'varType' is always @PredTy (EqPred t1 t2)@
coVarName :: CoVar -> Name
coVarName = varName
mkCoVar name kind = ASSERT( isCoercionKind kind )
TyVar { varName = name
, realUnique = getKeyFastInt (nameUnique name)
- , varType = kind
- -- varType is always PredTy (EqPred t1 t2)
+ , varType = kind
, isCoercionVar = True
}
mkWildCoVar :: Kind -> TyVar
--- A type variable that is never referred to,
--- so its unique doesn't matter
+-- ^ Create a type variable that is never referred to, so its unique doesn't matter
mkWildCoVar kind
= ASSERT( isCoercionKind kind )
TyVar { varName = mkSysTvName wild_uniq (fsLit "co_wild"),
isCoercionVar = True }
where
wild_uniq = mkBuiltinUnique 1
+
\end{code}
%************************************************************************
%* *
-\subsection{Id Construction}
+\subsection{Ids}
%* *
%************************************************************************
-Most Id-related functions are in Id.lhs and MkId.lhs
-
\begin{code}
-type Id = Var
-type DictId = Id
-\end{code}
-\begin{code}
-idName :: Id -> Name
-idUnique :: Id -> Unique
-idType :: Id -> Kind
+-- These synonyms are here and not in Id because otherwise we need a very
+-- large number of SOURCE imports of Id.hs :-(
+type Id = Var
+type DictId = Var
-idName = varName
-idUnique = varUnique
-idType = varType
-
-setIdUnique :: Id -> Unique -> Id
-setIdUnique = setVarUnique
-
-setIdName :: Id -> Name -> Id
-setIdName = setVarName
-
-setIdType :: Id -> Type -> Id
-setIdType id ty = id {varType = ty}
-
-setIdExported :: Id -> Id
--- Can be called on GlobalIds, such as data cons and class ops,
--- which are "born" as GlobalIds and automatically exported
-setIdExported id@(LocalId {}) = id { lclDetails = Exported }
-setIdExported other_id = ASSERT( isId other_id ) other_id
-
-setIdNotExported :: Id -> Id
--- We can only do this to LocalIds
-setIdNotExported id = ASSERT( isLocalId id ) id { lclDetails = NotExported }
-
-globaliseId :: GlobalIdDetails -> Id -> Id
--- If it's a local, make it global
-globaliseId details id = GlobalId { varName = varName id,
- realUnique = realUnique id,
- varType = varType id,
- idInfo_ = idInfo id,
- gblDetails = details }
-
-idInfo :: Id -> IdInfo
-idInfo (GlobalId {idInfo_ = info}) = info
-idInfo (LocalId {idInfo_ = info}) = info
-idInfo other_var = pprPanic "idInfo" (ppr other_var)
-
-lazySetIdInfo :: Id -> IdInfo -> Id
-lazySetIdInfo id info = id {idInfo_ = info}
-
-setIdInfo :: Id -> IdInfo -> Id
-setIdInfo id info = seqIdInfo info `seq` id {idInfo_ = info}
- -- Try to avoid spack leaks by seq'ing
-
-modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
-modifyIdInfo fn id
- = seqIdInfo new_info `seq` id {idInfo_ = new_info}
- where
- new_info = fn (idInfo id)
-
--- maybeModifyIdInfo tries to avoid unnecesary thrashing
-maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
-maybeModifyIdInfo (Just new_info) id = id {idInfo_ = new_info}
-maybeModifyIdInfo Nothing id = id
\end{code}
%************************************************************************
%* *
-\subsection{Predicates over variables
+\subsection{Predicates over variables}
%* *
%************************************************************************
\begin{code}
-mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
-mkGlobalId details name ty info
+-- | For an explanation of global vs. local 'Var's, see "Var#globalvslocal"
+mkGlobalIdVar :: GlobalIdDetails -> Name -> Type -> IdInfo -> Var
+mkGlobalIdVar details name ty info
= GlobalId { varName = name,
realUnique = getKeyFastInt (nameUnique name), -- Cache the unique
varType = ty,
gblDetails = details,
idInfo_ = info }
-mk_local_id :: Name -> Type -> LocalIdDetails -> IdInfo -> Id
-mk_local_id name ty details info
+mkLocalIdVar' :: Name -> Type -> LocalIdDetails -> IdInfo -> Var
+mkLocalIdVar' name ty details info
= LocalId { varName = name,
realUnique = getKeyFastInt (nameUnique name), -- Cache the unique
varType = ty,
lclDetails = details,
idInfo_ = info }
-mkLocalId :: Name -> Type -> IdInfo -> Id
-mkLocalId name ty info = mk_local_id name ty NotExported info
+-- | For an explanation of global vs. local 'Var's, see "Var#globalvslocal"
+mkLocalIdVar :: Name -> Type -> IdInfo -> Var
+mkLocalIdVar name ty info = mkLocalIdVar' name ty NotExported info
-mkExportedLocalId :: Name -> Type -> IdInfo -> Id
-mkExportedLocalId name ty info = mk_local_id name ty Exported info
+-- | Exported 'Var's will not be removed as dead code
+mkExportedLocalIdVar :: Name -> Type -> IdInfo -> Var
+mkExportedLocalIdVar name ty info = mkLocalIdVar' name ty Exported info
\end{code}
\begin{code}
-isTyVar, isTcTyVar :: Var -> Bool
-isId, isLocalVar, isLocalId :: Var -> Bool
-isGlobalId, isExportedId :: Var -> Bool
-mustHaveLocalBinding :: Var -> Bool
-isCoVar :: Var -> Bool
-
+isTyVar :: Var -> Bool
isTyVar (TyVar {}) = True
isTyVar (TcTyVar {}) = True
isTyVar _ = False
+isTcTyVar :: Var -> Bool
isTcTyVar (TcTyVar {}) = True
isTcTyVar _ = False
-isId (LocalId {}) = True
-isId (GlobalId {}) = True
-isId _ = False
+isIdVar :: Var -> Bool
+isIdVar (LocalId {}) = True
+isIdVar (GlobalId {}) = True
+isIdVar _ = False
-isLocalId (LocalId {}) = True
-isLocalId _ = False
+isLocalIdVar :: Var -> Bool
+isLocalIdVar (LocalId {}) = True
+isLocalIdVar _ = False
+isCoVar :: Var -> Bool
isCoVar (v@(TyVar {})) = isCoercionVar v
isCoVar _ = False
--- isLocalVar returns True for type variables as well as local Ids
+-- | 'isLocalVar' returns @True@ for type variables as well as local 'Id's
-- These are the variables that we need to pay attention to when finding free
-- variables, or doing dependency analysis.
+isLocalVar :: Var -> Bool
isLocalVar (GlobalId {}) = False
isLocalVar _ = True
--- mustHaveLocalBinding returns True of Ids and TyVars
+-- | 'mustHaveLocalBinding' returns @True@ of 'Id's and 'TyVar's
-- that must have a binding in this module. The converse
--- is not quite right: there are some GlobalIds that must have
+-- is not quite right: there are some global 'Id's that must have
-- bindings, such as record selectors. But that doesn't matter,
-- because it's only used for assertions
+mustHaveLocalBinding :: Var -> Bool
mustHaveLocalBinding var = isLocalVar var
-isGlobalId (GlobalId {}) = True
-isGlobalId _ = False
+isGlobalIdVar :: Var -> Bool
+isGlobalIdVar (GlobalId {}) = True
+isGlobalIdVar _ = False
--- isExportedId means "don't throw this away"
-isExportedId (GlobalId {}) = True
-isExportedId (LocalId {lclDetails = details})
+-- | 'isExportedIdVar' means \"don't throw this away\"
+isExportedIdVar :: Var -> Bool
+isExportedIdVar (GlobalId {}) = True
+isExportedIdVar (LocalId {lclDetails = details})
= case details of
Exported -> True
_ -> False
-isExportedId _ = False
+isExportedIdVar _ = False
\end{code}
\begin{code}
-globalIdDetails :: Var -> GlobalIdDetails
--- Works OK on local Ids too, returning notGlobalId
-globalIdDetails (GlobalId {gblDetails = details}) = details
-globalIdDetails _ = notGlobalId
+globalIdVarDetails :: Var -> GlobalIdDetails
+-- ^ Find the global 'Id' information if the 'Var' is a global 'Id', otherwise returns 'notGlobalId'
+globalIdVarDetails (GlobalId {gblDetails = details}) = details
+globalIdVarDetails _ = notGlobalId
\end{code}
-
#include "HsVersions.h"
-import Var
+import Var ( Var, TyVar, Id )
import Unique
import UniqSet
\end{code}
import CLabel
import ClosureInfo
import CostCentre
+import Id
import Var
import SMRep
import BasicTypes
lintAndScopeId :: Var -> (Var -> LintM a) -> LintM a
lintAndScopeId id linterF
= do { ty <- lintTy (idType id)
- ; let id' = Var.setIdType id ty
+ ; let id' = setIdType id ty
; addInScopeVars [id'] $ (linterF id')
}
-- Core rules
CoreRule(..), -- CoreSubst, CoreTidy, CoreFVs, PprCore only
RuleName, seqRules, ruleArity,
- isBuiltinRule, ruleName, isLocalRule, ruleIdName
+ isBuiltinRule, ruleName, isLocalRule, ruleIdName, setRuleIdName
) where
#include "HsVersions.h"
import CostCentre
import Var
+import Id
import Type
import Coercion
import Name
as the rule itself
\begin{code}
-type RuleName = FastString
-
data CoreRule
= Rule {
ru_name :: RuleName,
isLocalRule :: CoreRule -> Bool
isLocalRule = ru_local
+
+setRuleIdName :: Name -> CoreRule -> CoreRule
+setRuleIdName nm ru = ru { ru_fn = nm }
\end{code}
--- /dev/null
+\begin{code}
+module CoreSyn where
+
+-- Needed by Var.lhs
+--data Expr b
+--type CoreExpr = Expr Var.Var
+
+
+import Name ( Name )
+
+-- Needed by Id
+data CoreRule
+setRuleIdName :: Name -> CoreRule -> CoreRule
+seqRules :: [CoreRule] -> ()
+
+data Unfolding
+noUnfolding :: Unfolding
+\end{code}
make_tbind tv = (make_var_id (tyVarName tv), make_kind (tyVarKind tv))
make_vbind :: Var -> C.Vbind
-make_vbind v = (make_var_id (Var.varName v), make_ty (idType v))
+make_vbind v = (make_var_id (Var.varName v), make_ty (varType v))
make_vdef :: Bool -> CoreBind -> CoreM C.Vdefg
make_vdef topLevel b =
let local = not topLevel || localN
rhs <- make_exp e
-- use local flag to determine where to add the module name
- return (local, make_qid local True vName, make_ty (idType v),rhs)
+ return (local, make_qid local True vName, make_ty (varType v),rhs)
where vName = Var.varName v
make_exp :: CoreExpr -> CoreM C.Exp
let vName = Var.varName v
isLocal <- isALocal vName
return $
- case globalIdDetails v of
+ case globalIdVarDetails v of
FCallId (CCall (CCallSpec (StaticTarget nm) callconv _))
- -> C.External (unpackFS nm) (showSDoc (ppr callconv)) (make_ty (idType v))
+ -> C.External (unpackFS nm) (showSDoc (ppr callconv)) (make_ty (varType v))
FCallId (CCall (CCallSpec DynamicTarget callconv _))
- -> C.DynExternal (showSDoc (ppr callconv)) (make_ty (idType v))
+ -> C.DynExternal (showSDoc (ppr callconv)) (make_ty (varType v))
FCallId _
-> pprPanic "MkExternalCore died: can't handle non-{static,dynamic}-C foreign call"
(ppr v)
import ErrUtils
import Name
import Bag
-import Var
+import Id
import VarSet
import Data.List
import FastString
import Name
import Var
+import Id
import PrelInfo
import DataCon
import TysWiredIn
import DynFlags
import CoreUtils
-import Var
+import Id
import Type
import TysWiredIn
import Match
import HscTypes
import IdInfo
---import Id
+import Id
import Name
import Var hiding ( varName )
import VarSet
import HsTypes
import HsDoc
import NameSet
-import CoreSyn
import {- Kind parts of -} Type
import BasicTypes
import ForeignCall
#include "HsVersions.h"
-import CoreSyn
import IfaceType
import NewDemand
import TypeRep
import TyCon
+import Id
import Var
import TysWiredIn
import Name
= do { name <- lookupIfaceTop occ_name
; ty <- tcIfaceType iface_type
; info <- tcIdInfo ignore_prags name ty info
- ; return (AnId (mkVanillaGlobal name ty info)) }
+ ; return (AnId (mkVanillaGlobalWithInfo name ty info)) }
tcIfaceDecl _
(IfaceData {ifName = occ_name,
import Type hiding (typeKind)
import TcType hiding (typeKind)
import Id
-import Var hiding (setIdType)
+import Var
import TysPrim ( alphaTyVars )
import TyCon
import Class
import VarEnv ( emptyTidyEnv )
#endif
-import Var ( Id )
+import Id ( Id )
import Module ( emptyModuleEnv, ModLocation(..), Module )
import RdrName
import HsSyn
import CoreSyn ( CoreBind )
import VarEnv
import VarSet
-import Var hiding ( setIdType )
+import Var
import Id
import Type
import Type hiding (typeKind)
import TcType hiding (typeKind)
import InstEnv
-import Var hiding (setIdType)
+import Var
import Id
import IdInfo
import Name hiding ( varName )
import CoreUtils
import VarEnv
import VarSet
-import Var hiding( mkGlobalId )
+import Var
import Id
import IdInfo
import InstEnv
-- (NB: vanillaIdInfo makes a conservative assumption about Caf-hood.)
tidyExternalId id
= ASSERT2( isLocalId id && isExternalName (idName id), ppr id )
- mkVanillaGlobal (idName id) (tidyTopType (idType id)) vanillaIdInfo
+ mkVanillaGlobal (idName id) (tidyTopType (idType id))
\end{code}
import CoreUtils ( exprIsHNF, exprIsDupable )
import CoreLint ( showPass, endPass )
import CoreFVs ( CoreExprWithFVs, freeVars, freeVarsOf, idRuleVars )
-import Id ( isOneShotBndr )
+import Id ( isOneShotBndr, idType )
import Var
import Type ( isUnLiftedType )
import VarSet
module SAT ( doStaticArgs ) where
import DynFlags
-import Var hiding (mkLocalId)
+import Var
import CoreSyn
import CoreLint
import CoreUtils
import Type
import TyCon
import Id
-import Var ( Var, globalIdDetails, idType )
+import Var ( Var )
import IdInfo
import DataCon
import CostCentre ( noCCS )
import CostCentre ( CostCentreStack, CostCentre )
import VarSet ( IdSet, isEmptyVarSet )
-import Var ( isId )
-import Id ( Id, idName, idType, idCafInfo )
+import Id ( Id, idName, idType, idCafInfo, isId )
import IdInfo ( mayHaveCafRefs )
import Packages ( isDllName )
import Literal ( Literal, literalType )
import Type
import Coercion ( mkSymCoercion, splitNewTypeRepCo_maybe )
import BasicTypes ( Boxity(..) )
-import Var ( Var, isId )
+import Var ( Var, isIdVar )
import UniqSupply
import Unique
import Util ( zipWithEqual, notNull )
-- Don't do CPR if the worker doesn't have any value arguments
-- Then the worker is just a constant, so we don't want to unbox it.
(wrap_fn_cpr, work_fn_cpr, _cpr_res_ty)
- <- if any isId work_args then
+ <- if any isIdVar work_args then
mkWWcpr res_ty res_info
else
return (id, id, res_ty)
- return ([idNewDemandInfo v | v <- work_call_args, isId v],
+ return ([idNewDemandInfo v | v <- work_call_args, isIdVar v],
Note InlineMe . wrap_fn_args . wrap_fn_cpr . wrap_fn_str . applyToVars work_call_args . Var,
mkLams work_lam_args. work_fn_str . work_fn_cpr . work_fn_args)
-- We use an INLINE unconditionally, even if the wrapper turns out to be
-> ([Var], -- Lambda bound args
[Var]) -- Args at call site
mkWorkerArgs args res_ty
- | any isId args || not (isUnLiftedType res_ty)
+ | any isIdVar args || not (isUnLiftedType res_ty)
= (args, args)
| otherwise
= (args ++ [voidArgId], args ++ [realWorldPrimId])
import VarEnv
import TysPrim
import Id
-import IdInfo
-import Var hiding (mkLocalId)
+import Var
import Name
import NameSet
import NameEnv
where
tc_boot_sig (TypeSig (L _ name) ty)
= do { sigma_ty <- tcHsSigType (FunSigCtxt name) ty
- ; return (mkVanillaGlobal name sigma_ty vanillaIdInfo) }
+ ; return (mkVanillaGlobal name sigma_ty) }
-- Notice that we make GlobalIds, not LocalIds
tc_boot_sig s = pprPanic "tcHsBootSigs/tc_boot_sig" (ppr s)
tcHsBootSigs groups = pprPanic "tcHsBootSigs" (ppr groups)
import DataCon
import Class
import Var
+import Id
import MkId
import Name
import NameSet
import TcTyFuns
import DsUtils -- Big-tuple functions
import Var
+import Id
import Name
import NameSet
import Class
import Class
import TyCon
import DataCon
+import Id
import Var
import VarSet
import Name
-- others:
import DynFlags
-import CoreSyn
import Name
import NameSet
import VarEnv
return (vbody', lbody'))
where
(vs,ls) = unzip vvs
- tys = map idType vs
+ tys = map varType vs
mkVectEnv :: [Type] -> [Var] -> (Type, CoreExpr, CoreExpr -> CoreExpr -> CoreExpr)
mkVectEnv [] [] = (unitTy, Var unitDataConId, \_ body -> body)
projects / ghc-hetmet.git / commitdiff