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 newMutTyVar, newSigTyVar,
18 readMutTyVar, writeMutTyVar, makeTyVarImmutable,
22 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
23 setIdName, setIdUnique, setIdInfo, lazySetIdInfo,
24 setIdNoDiscard, zapSpecPragmaId,
26 globalIdDetails, setGlobalIdDetails,
28 mkLocalId, mkGlobalId, mkSpecPragmaId,
30 isTyVar, isMutTyVar, isSigTyVar,
31 isId, isLocalVar, isLocalId,
32 isGlobalId, isExportedId, isSpecPragmaId,
36 #include "HsVersions.h"
38 import {-# SOURCE #-} TypeRep( Type, Kind )
39 import {-# SOURCE #-} IdInfo( GlobalIdDetails, notGlobalId,
42 import Name ( Name, OccName, NamedThing(..),
43 setNameUnique, setNameOcc, nameUnique,
44 mkSysLocalName, isExternallyVisibleName
46 import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
50 import IOExts ( IORef, newIORef, readIORef, writeIORef )
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)
80 LocalIdDetails -- True <=> exported; don't discard even if dead
82 | GlobalId -- Used for imported Ids, dict selectors etc
86 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
87 Bool -- True <=> this is a type signature variable, which
88 -- should not be unified with a non-tyvar type
90 -- For a long time I tried to keep mutable Vars statically type-distinct
91 -- from immutable Vars, but I've finally given up. It's just too painful.
92 -- After type checking there are no MutTyVars left, but there's no static check
96 = NotExported -- Not exported
97 | Exported -- Exported
98 | SpecPragma -- Not exported, but not to be discarded either
99 -- It's unclean that this is so deeply built in
105 * always a constant (top-level)
106 * imported, or data constructor, or primop, or record selector
109 * bound within an expression (lambda, case, local let(rec))
110 * or defined at top level in the module being compiled
112 After CoreTidy, top-level LocalIds are turned into GlobalIds
116 instance Outputable Var where
117 ppr var = ppr (varName var)
119 instance Show Var where
120 showsPrec p var = showsPrecSDoc p (ppr var)
122 instance NamedThing Var where
125 instance Uniquable Var where
126 getUnique = varUnique
128 instance Eq Var where
129 a == b = realUnique a ==# realUnique b
131 instance Ord Var where
132 a <= b = realUnique a <=# realUnique b
133 a < b = realUnique a <# realUnique b
134 a >= b = realUnique a >=# realUnique b
135 a > b = realUnique a ># realUnique b
136 a `compare` b = varUnique a `compare` varUnique b
141 varUnique :: Var -> Unique
142 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
144 setVarUnique :: Var -> Unique -> Var
145 setVarUnique var@(Var {varName = name}) uniq
146 = var {realUnique = getKey uniq,
147 varName = setNameUnique name uniq}
149 setVarName :: Var -> Name -> Var
150 setVarName var new_name
151 = var { realUnique = getKey (getUnique new_name), varName = new_name }
153 setVarOcc :: Var -> OccName -> Var
154 setVarOcc var new_occ
155 = var { varName = setNameOcc (varName var) new_occ }
157 setVarType :: Var -> Type -> Var
158 setVarType var ty = var {varType = ty}
162 %************************************************************************
164 \subsection{Type variables}
166 %************************************************************************
176 setTyVarUnique = setVarUnique
177 setTyVarName = setVarName
181 mkTyVar :: Name -> Kind -> TyVar
182 mkTyVar name kind = Var { varName = name
183 , realUnique = getKey (nameUnique name)
186 , varInfo = pprPanic "mkTyVar" (ppr name)
189 mkSysTyVar :: Unique -> Kind -> TyVar
190 mkSysTyVar uniq kind = Var { varName = name
191 , realUnique = getKey uniq
194 , varInfo = pprPanic "mkSysTyVar" (ppr name)
197 name = mkSysLocalName uniq SLIT("t")
199 newMutTyVar :: Name -> Kind -> IO TyVar
200 newMutTyVar name kind = newTyVar name kind False
202 newSigTyVar :: Name -> Kind -> IO TyVar
203 -- Type variables from type signatures are still mutable, because
204 -- they may get unified with type variables from other signatures
205 -- But they do contain a flag to distinguish them, so we can tell if
206 -- we unify them with a non-type-variable.
207 newSigTyVar name kind = newTyVar name kind True
209 newTyVar name kind is_sig
210 = do loc <- newIORef Nothing
211 return (Var { varName = name
212 , realUnique = getKey (nameUnique name)
214 , varDetails = MutTyVar loc is_sig
215 , varInfo = pprPanic "newMutTyVar" (ppr name)
218 readMutTyVar :: TyVar -> IO (Maybe Type)
219 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
221 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
222 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
224 makeTyVarImmutable :: TyVar -> TyVar
225 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
229 %************************************************************************
231 \subsection{Id Construction}
233 %************************************************************************
235 Most Id-related functions are in Id.lhs and MkId.lhs
248 setIdUnique :: Id -> Unique -> Id
249 setIdUnique = setVarUnique
251 setIdName :: Id -> Name -> Id
252 setIdName = setVarName
254 setIdNoDiscard :: Id -> Id
256 = WARN( not (isLocalId id), ppr id )
257 id { varDetails = LocalId Exported }
259 zapSpecPragmaId :: Id -> Id
261 = case varDetails id of
262 LocalId SpecPragma -> id { varDetails = LocalId NotExported }
265 lazySetIdInfo :: Id -> IdInfo -> Id
266 lazySetIdInfo var info = var {varInfo = info}
268 setIdInfo :: Id -> IdInfo -> Id
269 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
270 -- Try to avoid spack leaks by seq'ing
272 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
273 modifyIdInfo fn var@(Var {varInfo = info})
274 = seqIdInfo new_info `seq` var {varInfo = new_info}
278 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
279 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
280 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
282 Just new_info -> var {varInfo = new_info}
285 %************************************************************************
287 \subsection{Predicates over variables
289 %************************************************************************
292 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
293 mkId name ty details info
294 = Var { varName = name,
295 realUnique = getKey (nameUnique name), -- Cache the unique
297 varDetails = details,
300 mkLocalId :: Name -> Type -> IdInfo -> Id
301 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
303 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
304 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
306 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
307 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
311 isTyVar, isMutTyVar, isSigTyVar :: Var -> Bool
312 isId, isLocalVar, isLocalId :: Var -> Bool
313 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
314 mustHaveLocalBinding :: Var -> Bool
316 isTyVar var = case varDetails var of
321 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
322 isMutTyVar other = False
324 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
325 isSigTyVar other = False
327 isId var = case varDetails var of
332 isLocalId var = case varDetails var of
336 -- isLocalVar returns True for type variables as well as local Ids
337 -- These are the variables that we need to pay attention to when finding free
338 -- variables, or doing dependency analysis.
339 isLocalVar var = case varDetails var of
345 -- mustHaveLocalBinding returns True of Ids and TyVars
346 -- that must have a binding in this module. The converse
347 -- is not quite right: there are some GlobalIds that must have
348 -- bindings, such as record selectors. But that doesn't matter,
349 -- because it's only used for assertions
350 mustHaveLocalBinding var = isLocalVar var
352 isGlobalId var = case varDetails var of
356 isExportedId var = case varDetails var of
357 LocalId Exported -> True
361 isSpecPragmaId var = case varDetails var of
362 LocalId SpecPragma -> True
367 globalIdDetails :: Var -> GlobalIdDetails
368 -- Works OK on local Ids too, returning notGlobalId
369 globalIdDetails var = case varDetails var of
370 GlobalId details -> details
372 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
373 setGlobalIdDetails id details = id { varDetails = GlobalId details }