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, readMutTyVar, writeMutTyVar, 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 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)
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 newMutTyVar :: Name -> Kind -> TyVarDetails -> IO TyVar
201 newMutTyVar name kind details
202 = do loc <- newIORef Nothing
203 return (Var { varName = name
204 , realUnique = getKey (nameUnique name)
206 , varDetails = MutTyVar loc details
207 , varInfo = pprPanic "newMutTyVar" (ppr name)
210 readMutTyVar :: TyVar -> IO (Maybe Type)
211 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
213 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
214 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
216 makeTyVarImmutable :: TyVar -> TyVar
217 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
219 mutTyVarDetails :: TyVar -> TyVarDetails
220 mutTyVarDetails (Var {varDetails = MutTyVar _ details}) = details
224 %************************************************************************
226 \subsection{Id Construction}
228 %************************************************************************
230 Most Id-related functions are in Id.lhs and MkId.lhs
243 setIdUnique :: Id -> Unique -> Id
244 setIdUnique = setVarUnique
246 setIdName :: Id -> Name -> Id
247 setIdName = setVarName
249 setIdLocalExported :: Id -> Id
250 setIdLocalExported id = id { varDetails = LocalId Exported }
252 zapSpecPragmaId :: Id -> Id
254 = case varDetails id of
255 LocalId SpecPragma -> id { varDetails = LocalId NotExported }
258 lazySetIdInfo :: Id -> IdInfo -> Id
259 lazySetIdInfo var info = var {varInfo = info}
261 setIdInfo :: Id -> IdInfo -> Id
262 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
263 -- Try to avoid spack leaks by seq'ing
265 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
266 modifyIdInfo fn var@(Var {varInfo = info})
267 = seqIdInfo new_info `seq` var {varInfo = new_info}
271 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
272 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
273 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
275 Just new_info -> var {varInfo = new_info}
278 %************************************************************************
280 \subsection{Predicates over variables
282 %************************************************************************
285 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
286 mkId name ty details info
287 = Var { varName = name,
288 realUnique = getKey (nameUnique name), -- Cache the unique
290 varDetails = details,
293 mkLocalId :: Name -> Type -> IdInfo -> Id
294 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
296 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
297 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
299 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
300 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
304 isTyVar, isMutTyVar :: Var -> Bool
305 isId, isLocalVar, isLocalId :: Var -> Bool
306 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
307 mustHaveLocalBinding :: Var -> Bool
309 isTyVar var = case varDetails var of
314 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
315 isMutTyVar other = False
318 isId var = case varDetails var of
323 isLocalId var = case varDetails var of
327 -- isLocalVar returns True for type variables as well as local Ids
328 -- These are the variables that we need to pay attention to when finding free
329 -- variables, or doing dependency analysis.
330 isLocalVar var = case varDetails var of
336 -- mustHaveLocalBinding returns True of Ids and TyVars
337 -- that must have a binding in this module. The converse
338 -- is not quite right: there are some GlobalIds that must have
339 -- bindings, such as record selectors. But that doesn't matter,
340 -- because it's only used for assertions
341 mustHaveLocalBinding var = isLocalVar var
343 isGlobalId var = case varDetails var of
347 -- isExportedId means "don't throw this away"
348 isExportedId var = case varDetails var of
349 LocalId Exported -> True
350 LocalId SpecPragma -> True
354 isSpecPragmaId var = case varDetails var of
355 LocalId SpecPragma -> True
360 globalIdDetails :: Var -> GlobalIdDetails
361 -- Works OK on local Ids too, returning notGlobalId
362 globalIdDetails var = case varDetails var of
363 GlobalId details -> details
365 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
366 setGlobalIdDetails id details = id { varDetails = GlobalId details }