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 =
174 do loc <- newIORef Nothing
175 return (Var { varName = name
176 , realUnique = getKey (nameUnique name)
178 , varDetails = MutTyVar loc False
179 , varInfo = pprPanic "newMutTyVar" (ppr name)
182 newSigTyVar :: Name -> Kind -> IO TyVar
183 newSigTyVar name kind =
184 do loc <- newIORef Nothing
185 return (Var { varName = name
186 , realUnique = getKey (nameUnique name)
188 , varDetails = MutTyVar loc True
189 , varInfo = pprPanic "newSigTyVar" (ppr name)
192 readMutTyVar :: TyVar -> IO (Maybe Type)
193 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
195 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
196 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
198 makeTyVarImmutable :: TyVar -> TyVar
199 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
201 isTyVar :: Var -> Bool
202 isTyVar (Var {varDetails = details}) = case details of
207 isMutTyVar :: Var -> Bool
208 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
209 isMutTyVar other = False
211 isSigTyVar :: Var -> Bool
212 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
213 isSigTyVar other = False
217 %************************************************************************
219 \subsection{Usage variables}
221 %************************************************************************
228 mkUVar :: Unique -> UVar
229 mkUVar unique = Var { varName = name
230 , realUnique = getKey unique
232 , varType = pprPanic "mkUVar (varType)" (ppr name)
233 , varInfo = pprPanic "mkUVar (varInfo)" (ppr name)
235 where name = mkSysLocalName unique SLIT("u")
237 mkNamedUVar :: Name -> UVar
238 mkNamedUVar name = Var { varName = name
239 , realUnique = getKey (nameUnique name)
241 , varType = pprPanic "mkNamedUVar (varType)" (ppr name)
242 , varInfo = pprPanic "mkNamedUVar (varInfo)" (ppr name)
247 isUVar :: Var -> Bool
248 isUVar (Var {varDetails = details}) = case details of
254 %************************************************************************
256 \subsection{Id Construction}
258 %************************************************************************
260 Most Id-related functions are in Id.lhs and MkId.lhs
273 setIdUnique :: Id -> Unique -> Id
274 setIdUnique = setVarUnique
276 setIdName :: Id -> Name -> Id
277 setIdName = setVarName
279 lazySetIdInfo :: Id -> IdInfo -> Id
280 lazySetIdInfo var info = var {varInfo = info}
282 setIdInfo :: Id -> IdInfo -> Id
283 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
284 -- Try to avoid spack leaks by seq'ing
286 zapIdInfo :: Id -> Id
287 zapIdInfo var = var {varInfo = vanillaIdInfo}
289 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
290 modifyIdInfo fn var@(Var {varInfo = info})
291 = seqIdInfo new_info `seq` var {varInfo = new_info}
295 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
296 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
297 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
299 Just new_info -> var {varInfo = new_info}
303 mkIdVar :: Name -> Type -> IdInfo -> Id
305 = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
306 varDetails = AnId, varInfo = info}
311 isId (Var {varDetails = AnId}) = True
315 @externallyVisibleId@: is it true that another module might be
316 able to ``see'' this Id in a code generation sense. That
317 is, another .o file might refer to this Id.
319 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
320 local-ness precisely so that the test here would be easy
322 This defn appears here (rather than, say, in Id.lhs) because
323 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
327 externallyVisibleId :: Id -> Bool
328 externallyVisibleId var = isExternallyVisibleName (varName var)