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;
88 -- TODO: the IORef should be unboxed here, but we don't want to unbox
91 -- For a long time I tried to keep mutable Vars statically
92 -- type-distinct from immutable Vars, but I've finally given
93 -- up. It's just too painful. After type checking there are
94 -- no MutTyVars left, but there's no static check of that
98 = NotExported -- Not exported
99 | Exported -- Exported
100 | SpecPragma -- Not exported, but not to be discarded either
101 -- It's unclean that this is so deeply built in
107 * always a constant (top-level)
108 * imported, or data constructor, or primop, or record selector
109 * has a Unique that is globally unique across the whole
110 GHC invocation (a single invocation may compile multiple modules)
113 * bound within an expression (lambda, case, local let(rec))
114 * or defined at top level in the module being compiled
116 After CoreTidy, top-level LocalIds are turned into GlobalIds
120 instance Outputable Var where
121 ppr var = ppr (varName var)
123 instance Show Var where
124 showsPrec p var = showsPrecSDoc p (ppr var)
126 instance NamedThing Var where
129 instance Uniquable Var where
130 getUnique = varUnique
132 instance Eq Var where
133 a == b = realUnique a ==# realUnique b
135 instance Ord Var where
136 a <= b = realUnique a <=# realUnique b
137 a < b = realUnique a <# realUnique b
138 a >= b = realUnique a >=# realUnique b
139 a > b = realUnique a ># realUnique b
140 a `compare` b = varUnique a `compare` varUnique b
145 varUnique :: Var -> Unique
146 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
148 setVarUnique :: Var -> Unique -> Var
149 setVarUnique var@(Var {varName = name}) uniq
150 = var {realUnique = getKey uniq,
151 varName = setNameUnique name uniq}
153 setVarName :: Var -> Name -> Var
154 setVarName var new_name
155 = var { realUnique = getKey (getUnique new_name), varName = new_name }
157 setVarOcc :: Var -> OccName -> Var
158 setVarOcc var new_occ
159 = var { varName = setNameOcc (varName var) new_occ }
161 setVarType :: Var -> Type -> Var
162 setVarType var ty = var {varType = ty}
166 %************************************************************************
168 \subsection{Type variables}
170 %************************************************************************
180 setTyVarUnique = setVarUnique
181 setTyVarName = setVarName
185 mkTyVar :: Name -> Kind -> TyVar
186 mkTyVar name kind = Var { varName = name
187 , realUnique = getKey (nameUnique name)
190 , varInfo = pprPanic "mkTyVar" (ppr name)
193 mkSysTyVar :: Unique -> Kind -> TyVar
194 mkSysTyVar uniq kind = Var { varName = name
195 , realUnique = getKey uniq
198 , varInfo = pprPanic "mkSysTyVar" (ppr name)
201 name = mkSystemTvNameEncoded uniq FSLIT("t")
203 mkMutTyVar :: Name -> Kind -> TyVarDetails -> IORef (Maybe Type) -> TyVar
204 mkMutTyVar name kind details ref
205 = Var { varName = name
206 , realUnique = getKey (nameUnique name)
208 , varDetails = MutTyVar ref details
209 , varInfo = pprPanic "newMutTyVar" (ppr name)
212 mutTyVarRef :: TyVar -> IORef (Maybe Type)
213 mutTyVarRef (Var {varDetails = MutTyVar loc _}) = loc
215 makeTyVarImmutable :: TyVar -> TyVar
216 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
218 mutTyVarDetails :: TyVar -> TyVarDetails
219 mutTyVarDetails (Var {varDetails = MutTyVar _ details}) = details
223 %************************************************************************
225 \subsection{Id Construction}
227 %************************************************************************
229 Most Id-related functions are in Id.lhs and MkId.lhs
242 setIdUnique :: Id -> Unique -> Id
243 setIdUnique = setVarUnique
245 setIdName :: Id -> Name -> Id
246 setIdName = setVarName
248 setIdLocalExported :: Id -> Id
249 setIdLocalExported id = id { varDetails = LocalId Exported }
251 zapSpecPragmaId :: Id -> Id
253 = case varDetails id of
254 LocalId SpecPragma -> id { varDetails = LocalId NotExported }
257 lazySetIdInfo :: Id -> IdInfo -> Id
258 lazySetIdInfo var info = var {varInfo = info}
260 setIdInfo :: Id -> IdInfo -> Id
261 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
262 -- Try to avoid spack leaks by seq'ing
264 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
265 modifyIdInfo fn var@(Var {varInfo = info})
266 = seqIdInfo new_info `seq` var {varInfo = new_info}
270 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
271 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
272 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
274 Just new_info -> var {varInfo = new_info}
277 %************************************************************************
279 \subsection{Predicates over variables
281 %************************************************************************
284 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
285 mkId name ty details info
286 = Var { varName = name,
287 realUnique = getKey (nameUnique name), -- Cache the unique
289 varDetails = details,
292 mkLocalId :: Name -> Type -> IdInfo -> Id
293 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
295 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
296 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
298 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
299 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
303 isTyVar, isMutTyVar :: Var -> Bool
304 isId, isLocalVar, isLocalId :: Var -> Bool
305 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
306 mustHaveLocalBinding :: Var -> Bool
308 isTyVar var = case varDetails var of
313 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
314 isMutTyVar other = False
317 isId var = case varDetails var of
322 isLocalId var = case varDetails var of
326 -- isLocalVar returns True for type variables as well as local Ids
327 -- These are the variables that we need to pay attention to when finding free
328 -- variables, or doing dependency analysis.
329 isLocalVar var = case varDetails var of
335 -- mustHaveLocalBinding returns True of Ids and TyVars
336 -- that must have a binding in this module. The converse
337 -- is not quite right: there are some GlobalIds that must have
338 -- bindings, such as record selectors. But that doesn't matter,
339 -- because it's only used for assertions
340 mustHaveLocalBinding var = isLocalVar var
342 isGlobalId var = case varDetails var of
346 -- isExportedId means "don't throw this away"
347 isExportedId var = case varDetails var of
348 LocalId Exported -> True
349 LocalId SpecPragma -> True
353 isSpecPragmaId var = case varDetails var of
354 LocalId SpecPragma -> True
359 globalIdDetails :: Var -> GlobalIdDetails
360 -- Works OK on local Ids too, returning notGlobalId
361 globalIdDetails var = case varDetails var of
362 GlobalId details -> details
364 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
365 setGlobalIdDetails id details = id { varDetails = GlobalId details }