2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section{@Vars@: Variables}
8 Var, VarDetails, -- Abstract
9 varName, varUnique, varInfo, varType,
10 setVarName, setVarUnique, setVarType, setVarOcc,
15 setTyVarName, setTyVarUnique,
17 mkMutTyVar, mutTyVarRef, makeTyVarImmutable,
21 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
22 setIdName, setIdUnique, setIdInfo, lazySetIdInfo,
23 setIdLocalExported, zapSpecPragmaId,
25 globalIdDetails, setGlobalIdDetails,
27 mkLocalId, mkGlobalId, mkSpecPragmaId,
29 isTyVar, isMutTyVar, mutTyVarDetails,
30 isId, isLocalVar, isLocalId,
31 isGlobalId, isExportedId, isSpecPragmaId,
35 #include "HsVersions.h"
37 import {-# SOURCE #-} TypeRep( Type, Kind )
38 import {-# SOURCE #-} TcType( TyVarDetails )
39 import {-# SOURCE #-} IdInfo( GlobalIdDetails, notGlobalId,
42 import Name ( Name, OccName, NamedThing(..),
43 setNameUnique, setNameOcc, nameUnique,
44 mkSystemTvNameEncoded,
46 import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
50 import DATA_IOREF ( IORef )
54 %************************************************************************
56 \subsection{The main data type declarations}
58 %************************************************************************
61 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
62 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
63 strictness). The essential info about different kinds of @Vars@ is
70 realUnique :: FastInt, -- Key for fast comparison
71 -- Identical to the Unique in the name,
72 -- cached here for speed
74 varDetails :: VarDetails,
75 varInfo :: IdInfo -- Only used for Ids at the moment
79 = LocalId -- Used for locally-defined Ids (see NOTE below)
82 | GlobalId -- Used for imported Ids, dict selectors etc
86 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
89 -- For a long time I tried to keep mutable Vars statically type-distinct
90 -- from immutable Vars, but I've finally given up. It's just too painful.
91 -- After type checking there are no MutTyVars left, but there's no static check
95 = NotExported -- Not exported
96 | Exported -- Exported
97 | SpecPragma -- Not exported, but not to be discarded either
98 -- It's unclean that this is so deeply built in
104 * always a constant (top-level)
105 * imported, or data constructor, or primop, or record selector
106 * has a Unique that is globally unique across the whole
107 GHC invocation (a single invocation may compile multiple modules)
110 * bound within an expression (lambda, case, local let(rec))
111 * or defined at top level in the module being compiled
113 After CoreTidy, top-level LocalIds are turned into GlobalIds
117 instance Outputable Var where
118 ppr var = ppr (varName var)
120 instance Show Var where
121 showsPrec p var = showsPrecSDoc p (ppr var)
123 instance NamedThing Var where
126 instance Uniquable Var where
127 getUnique = varUnique
129 instance Eq Var where
130 a == b = realUnique a ==# realUnique b
132 instance Ord Var where
133 a <= b = realUnique a <=# realUnique b
134 a < b = realUnique a <# realUnique b
135 a >= b = realUnique a >=# realUnique b
136 a > b = realUnique a ># realUnique b
137 a `compare` b = varUnique a `compare` varUnique b
142 varUnique :: Var -> Unique
143 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
145 setVarUnique :: Var -> Unique -> Var
146 setVarUnique var@(Var {varName = name}) uniq
147 = var {realUnique = getKey uniq,
148 varName = setNameUnique name uniq}
150 setVarName :: Var -> Name -> Var
151 setVarName var new_name
152 = var { realUnique = getKey (getUnique new_name), varName = new_name }
154 setVarOcc :: Var -> OccName -> Var
155 setVarOcc var new_occ
156 = var { varName = setNameOcc (varName var) new_occ }
158 setVarType :: Var -> Type -> Var
159 setVarType var ty = var {varType = ty}
163 %************************************************************************
165 \subsection{Type variables}
167 %************************************************************************
177 setTyVarUnique = setVarUnique
178 setTyVarName = setVarName
182 mkTyVar :: Name -> Kind -> TyVar
183 mkTyVar name kind = Var { varName = name
184 , realUnique = getKey (nameUnique name)
187 , varInfo = pprPanic "mkTyVar" (ppr name)
190 mkSysTyVar :: Unique -> Kind -> TyVar
191 mkSysTyVar uniq kind = Var { varName = name
192 , realUnique = getKey uniq
195 , varInfo = pprPanic "mkSysTyVar" (ppr name)
198 name = mkSystemTvNameEncoded uniq FSLIT("t")
200 mkMutTyVar :: Name -> Kind -> TyVarDetails -> IORef (Maybe Type) -> TyVar
201 mkMutTyVar name kind details ref
202 = Var { varName = name
203 , realUnique = getKey (nameUnique name)
205 , varDetails = MutTyVar ref details
206 , varInfo = pprPanic "newMutTyVar" (ppr name)
209 mutTyVarRef :: TyVar -> IORef (Maybe Type)
210 mutTyVarRef (Var {varDetails = MutTyVar loc _}) = loc
212 makeTyVarImmutable :: TyVar -> TyVar
213 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
215 mutTyVarDetails :: TyVar -> TyVarDetails
216 mutTyVarDetails (Var {varDetails = MutTyVar _ details}) = details
220 %************************************************************************
222 \subsection{Id Construction}
224 %************************************************************************
226 Most Id-related functions are in Id.lhs and MkId.lhs
239 setIdUnique :: Id -> Unique -> Id
240 setIdUnique = setVarUnique
242 setIdName :: Id -> Name -> Id
243 setIdName = setVarName
245 setIdLocalExported :: Id -> Id
246 setIdLocalExported id = id { varDetails = LocalId Exported }
248 zapSpecPragmaId :: Id -> Id
250 = case varDetails id of
251 LocalId SpecPragma -> id { varDetails = LocalId NotExported }
254 lazySetIdInfo :: Id -> IdInfo -> Id
255 lazySetIdInfo var info = var {varInfo = info}
257 setIdInfo :: Id -> IdInfo -> Id
258 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
259 -- Try to avoid spack leaks by seq'ing
261 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
262 modifyIdInfo fn var@(Var {varInfo = info})
263 = seqIdInfo new_info `seq` var {varInfo = new_info}
267 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
268 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
269 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
271 Just new_info -> var {varInfo = new_info}
274 %************************************************************************
276 \subsection{Predicates over variables
278 %************************************************************************
281 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
282 mkId name ty details info
283 = Var { varName = name,
284 realUnique = getKey (nameUnique name), -- Cache the unique
286 varDetails = details,
289 mkLocalId :: Name -> Type -> IdInfo -> Id
290 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
292 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
293 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
295 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
296 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
300 isTyVar, isMutTyVar :: Var -> Bool
301 isId, isLocalVar, isLocalId :: Var -> Bool
302 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
303 mustHaveLocalBinding :: Var -> Bool
305 isTyVar var = case varDetails var of
310 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
311 isMutTyVar other = False
314 isId var = case varDetails var of
319 isLocalId var = case varDetails var of
323 -- isLocalVar returns True for type variables as well as local Ids
324 -- These are the variables that we need to pay attention to when finding free
325 -- variables, or doing dependency analysis.
326 isLocalVar var = case varDetails var of
332 -- mustHaveLocalBinding returns True of Ids and TyVars
333 -- that must have a binding in this module. The converse
334 -- is not quite right: there are some GlobalIds that must have
335 -- bindings, such as record selectors. But that doesn't matter,
336 -- because it's only used for assertions
337 mustHaveLocalBinding var = isLocalVar var
339 isGlobalId var = case varDetails var of
343 -- isExportedId means "don't throw this away"
344 isExportedId var = case varDetails var of
345 LocalId Exported -> True
346 LocalId SpecPragma -> True
350 isSpecPragmaId var = case varDetails var of
351 LocalId SpecPragma -> True
356 globalIdDetails :: Var -> GlobalIdDetails
357 -- Works OK on local Ids too, returning notGlobalId
358 globalIdDetails var = case varDetails var of
359 GlobalId details -> details
361 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
362 setGlobalIdDetails id details = id { varDetails = GlobalId details }