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,
16 mkTyVar, mkSysTyVar, isTyVar, isSigTyVar,
17 newMutTyVar, newSigTyVar,
18 readMutTyVar, writeMutTyVar, isMutTyVar, makeTyVarImmutable,
27 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
28 setIdName, setIdUnique, setIdInfo, lazySetIdInfo, zapIdInfo,
29 mkIdVar, isId, externallyVisibleId
32 #include "HsVersions.h"
34 import {-# SOURCE #-} TypeRep( Type, Kind )
35 import {-# SOURCE #-} IdInfo( IdInfo, seqIdInfo, vanillaIdInfo )
37 import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
38 import Name ( Name, OccName, NamedThing(..),
39 setNameUnique, setNameOcc, nameUnique,
40 mkSysLocalName, isExternallyVisibleName
42 import BasicTypes ( Unused )
45 import IOExts ( IORef, newIORef, readIORef, writeIORef )
50 %************************************************************************
52 \subsection{The main data type declarations}
54 %************************************************************************
57 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
58 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
59 strictness). The essential info about different kinds of @Vars@ is
66 realUnique :: Int#, -- Key for fast comparison
67 -- Identical to the Unique in the name,
68 -- cached here for speed
70 varDetails :: VarDetails,
71 varInfo :: IdInfo -- Only used for Ids at the moment
77 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
78 Bool -- True <=> this is a type signature variable, which
79 -- should not be unified with a non-tyvar type
80 | UVar -- Usage variable
82 -- For a long time I tried to keep mutable Vars statically type-distinct
83 -- from immutable Vars, but I've finally given up. It's just too painful.
84 -- After type checking there are no MutTyVars left, but there's no static check
89 instance Outputable Var where
90 ppr var = ppr (varName var)
92 instance Show Var where
93 showsPrec p var = showsPrecSDoc p (ppr var)
95 instance NamedThing Var where
98 instance Uniquable Var where
101 instance Eq Var where
102 a == b = realUnique a ==# realUnique b
104 instance Ord Var where
105 a <= b = realUnique a <=# realUnique b
106 a < b = realUnique a <# realUnique b
107 a >= b = realUnique a >=# realUnique b
108 a > b = realUnique a ># realUnique b
109 a `compare` b = varUnique a `compare` varUnique b
114 varUnique :: Var -> Unique
115 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
117 setVarUnique :: Var -> Unique -> Var
118 setVarUnique var@(Var {varName = name}) uniq
119 = var {realUnique = getKey uniq,
120 varName = setNameUnique name uniq}
122 setVarName :: Var -> Name -> Var
123 setVarName var new_name
124 = var { realUnique = getKey (getUnique new_name), varName = new_name }
126 setVarOcc :: Var -> OccName -> Var
127 setVarOcc var new_occ
128 = var { varName = setNameOcc (varName var) new_occ }
130 setVarType :: Var -> Type -> Var
131 setVarType var ty = var {varType = ty}
135 %************************************************************************
137 \subsection{Type variables}
139 %************************************************************************
149 setTyVarUnique = setVarUnique
150 setTyVarName = setVarName
154 mkTyVar :: Name -> Kind -> TyVar
155 mkTyVar name kind = Var { varName = name
156 , realUnique = getKey (nameUnique name)
159 , varInfo = pprPanic "mkTyVar" (ppr name)
162 mkSysTyVar :: Unique -> Kind -> TyVar
163 mkSysTyVar uniq kind = Var { varName = name
164 , realUnique = getKey uniq
167 , varInfo = pprPanic "mkSysTyVar" (ppr name)
170 name = mkSysLocalName uniq SLIT("t")
172 newMutTyVar :: Name -> Kind -> IO TyVar
173 newMutTyVar name kind = newTyVar name kind False
175 newSigTyVar :: Name -> Kind -> IO TyVar
176 -- Type variables from type signatures are still mutable, because
177 -- they may get unified with type variables from other signatures
178 -- But they do contain a flag to distinguish them, so we can tell if
179 -- we unify them with a non-type-variable.
180 newSigTyVar name kind = newTyVar name kind True
182 newTyVar name kind is_sig
183 = do loc <- newIORef Nothing
184 return (Var { varName = name
185 , realUnique = getKey (nameUnique name)
187 , varDetails = MutTyVar loc is_sig
188 , varInfo = pprPanic "newMutTyVar" (ppr name)
191 readMutTyVar :: TyVar -> IO (Maybe Type)
192 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
194 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
195 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
197 makeTyVarImmutable :: TyVar -> TyVar
198 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
200 isTyVar :: Var -> Bool
201 isTyVar (Var {varDetails = details}) = case details of
206 isMutTyVar :: Var -> Bool
207 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
208 isMutTyVar other = False
210 isSigTyVar :: Var -> Bool
211 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
212 isSigTyVar other = False
216 %************************************************************************
218 \subsection{Usage variables}
220 %************************************************************************
227 mkUVar :: Unique -> UVar
228 mkUVar unique = Var { varName = name
229 , realUnique = getKey unique
231 , varType = pprPanic "mkUVar (varType)" (ppr name)
232 , varInfo = pprPanic "mkUVar (varInfo)" (ppr name)
234 where name = mkSysLocalName unique SLIT("u")
236 mkNamedUVar :: Name -> UVar
237 mkNamedUVar name = Var { varName = name
238 , realUnique = getKey (nameUnique name)
240 , varType = pprPanic "mkNamedUVar (varType)" (ppr name)
241 , varInfo = pprPanic "mkNamedUVar (varInfo)" (ppr name)
246 isUVar :: Var -> Bool
247 isUVar (Var {varDetails = details}) = case details of
253 %************************************************************************
255 \subsection{Id Construction}
257 %************************************************************************
259 Most Id-related functions are in Id.lhs and MkId.lhs
272 setIdUnique :: Id -> Unique -> Id
273 setIdUnique = setVarUnique
275 setIdName :: Id -> Name -> Id
276 setIdName = setVarName
278 lazySetIdInfo :: Id -> IdInfo -> Id
279 lazySetIdInfo var info = var {varInfo = info}
281 setIdInfo :: Id -> IdInfo -> Id
282 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
283 -- Try to avoid spack leaks by seq'ing
285 zapIdInfo :: Id -> Id
286 zapIdInfo var = var {varInfo = vanillaIdInfo}
288 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
289 modifyIdInfo fn var@(Var {varInfo = info})
290 = seqIdInfo new_info `seq` var {varInfo = new_info}
294 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
295 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
296 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
298 Just new_info -> var {varInfo = new_info}
302 mkIdVar :: Name -> Type -> IdInfo -> Id
304 = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
305 varDetails = AnId, varInfo = info}
310 isId (Var {varDetails = AnId}) = True
314 @externallyVisibleId@: is it true that another module might be
315 able to ``see'' this Id in a code generation sense. That
316 is, another .o file might refer to this Id.
318 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
319 local-ness precisely so that the test here would be easy
321 This defn appears here (rather than, say, in Id.lhs) because
322 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
326 externallyVisibleId :: Id -> Bool
327 externallyVisibleId var = isExternallyVisibleName (varName var)