2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section{@Vars@: Variables}
8 Var, IdOrTyVar, VarDetails, -- Abstract
9 varName, varUnique, varInfo, varType,
10 setVarName, setVarUnique, setVarType, setVarOcc,
16 setTyVarName, setTyVarUnique,
17 mkTyVar, mkSysTyVar, isTyVar, isSigTyVar,
18 newMutTyVar, newSigTyVar,
19 readMutTyVar, writeMutTyVar, isMutTyVar, makeTyVarImmutable,
28 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
29 setIdName, setIdUnique, setIdInfo, lazySetIdInfo, zapIdInfo,
30 mkIdVar, isId, externallyVisibleId
33 #include "HsVersions.h"
35 import {-# SOURCE #-} TypeRep( Type, Kind )
36 import {-# SOURCE #-} IdInfo( IdInfo, seqIdInfo, vanillaIdInfo )
38 import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
39 import Name ( Name, OccName, NamedThing(..),
40 setNameUnique, setNameOcc, nameUnique,
41 mkSysLocalName, isExternallyVisibleName
43 import BasicTypes ( Unused )
46 import IOExts ( IORef, newIORef, readIORef, writeIORef )
51 %************************************************************************
53 \subsection{The main data type declarations}
55 %************************************************************************
58 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
59 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
60 strictness). The essential info about different kinds of @Vars@ is
69 realUnique :: Int#, -- Key for fast comparison
70 -- Identical to the Unique in the name,
71 -- cached here for speed
73 varDetails :: VarDetails,
74 varInfo :: IdInfo -- Only used for Ids at the moment
80 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
81 Bool -- True <=> this is a type signature variable, which
82 -- should not be unified with a non-tyvar type
83 | UVar -- Usage variable
85 -- For a long time I tried to keep mutable Vars statically type-distinct
86 -- from immutable Vars, but I've finally given up. It's just too painful.
87 -- After type checking there are no MutTyVars left, but there's no static check
92 instance Outputable Var where
93 ppr var = ppr (varName var)
95 instance Show Var where
96 showsPrec p var = showsPrecSDoc p (ppr var)
98 instance NamedThing Var where
101 instance Uniquable Var where
102 getUnique = varUnique
104 instance Eq Var where
105 a == b = realUnique a ==# realUnique b
107 instance Ord Var where
108 a <= b = realUnique a <=# realUnique b
109 a < b = realUnique a <# realUnique b
110 a >= b = realUnique a >=# realUnique b
111 a > b = realUnique a ># realUnique b
112 a `compare` b = varUnique a `compare` varUnique b
117 varUnique :: Var -> Unique
118 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
120 setVarUnique :: Var -> Unique -> Var
121 setVarUnique var@(Var {varName = name}) uniq
122 = var {realUnique = getKey uniq,
123 varName = setNameUnique name uniq}
125 setVarName :: Var -> Name -> Var
126 setVarName var new_name
127 = var { realUnique = getKey (getUnique new_name), varName = new_name }
129 setVarOcc :: Var -> OccName -> Var
130 setVarOcc var new_occ
131 = var { varName = setNameOcc (varName var) new_occ }
133 setVarType :: Var -> Type -> Var
134 setVarType var ty = var {varType = ty}
138 %************************************************************************
140 \subsection{Type variables}
142 %************************************************************************
152 setTyVarUnique = setVarUnique
153 setTyVarName = setVarName
157 mkTyVar :: Name -> Kind -> TyVar
158 mkTyVar name kind = Var { varName = name
159 , realUnique = getKey (nameUnique name)
163 , varInfo = pprPanic "looking at IdInfo of a tyvar" (ppr name)
167 mkSysTyVar :: Unique -> Kind -> TyVar
168 mkSysTyVar uniq kind = Var { varName = name
169 , realUnique = getKey uniq
173 , varInfo = pprPanic "mkSysTyVar" (ppr name)
177 name = mkSysLocalName uniq SLIT("t")
179 newMutTyVar :: Name -> Kind -> IO TyVar
180 newMutTyVar name kind =
181 do loc <- newIORef Nothing
182 return (Var { varName = name,
183 realUnique = getKey (nameUnique name),
185 varDetails = MutTyVar loc False})
187 newSigTyVar :: Name -> Kind -> IO TyVar
188 newSigTyVar name kind =
189 do loc <- newIORef Nothing
190 return (Var { varName = name,
191 realUnique = getKey (nameUnique name),
193 varDetails = MutTyVar loc True})
195 readMutTyVar :: TyVar -> IO (Maybe Type)
196 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
198 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
199 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
201 makeTyVarImmutable :: TyVar -> TyVar
202 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
204 isTyVar :: Var -> Bool
205 isTyVar (Var {varDetails = details}) = case details of
210 isMutTyVar :: Var -> Bool
211 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
212 isMutTyVar other = False
214 isSigTyVar :: Var -> Bool
215 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
216 isSigTyVar other = False
220 %************************************************************************
222 \subsection{Usage variables}
224 %************************************************************************
231 mkUVar :: Unique -> UVar
232 mkUVar unique = Var { varName = mkSysLocalName unique SLIT("u"),
233 realUnique = getKey unique,
236 mkNamedUVar :: Name -> UVar
237 mkNamedUVar name = Var { varName = name
238 , realUnique = getKey (nameUnique name)
241 , varType = pprPanic "looking at Type of a uvar" (ppr name)
242 , varInfo = pprPanic "looking at IdInfo of a uvar" (ppr name)
248 isUVar :: Var -> Bool
249 isUVar (Var {varDetails = details}) = case details of
255 %************************************************************************
257 \subsection{Id Construction}
259 %************************************************************************
261 Most Id-related functions are in Id.lhs and MkId.lhs
274 setIdUnique :: Id -> Unique -> Id
275 setIdUnique = setVarUnique
277 setIdName :: Id -> Name -> Id
278 setIdName = setVarName
280 lazySetIdInfo :: Id -> IdInfo -> Id
281 lazySetIdInfo var info = var {varInfo = info}
283 setIdInfo :: Id -> IdInfo -> Id
284 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
285 -- Try to avoid spack leaks by seq'ing
287 zapIdInfo :: Id -> Id
288 zapIdInfo var = var {varInfo = vanillaIdInfo}
290 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
291 modifyIdInfo fn var@(Var {varInfo = info})
292 = seqIdInfo new_info `seq` var {varInfo = new_info}
296 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
297 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
298 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
300 Just new_info -> var {varInfo = new_info}
304 mkIdVar :: Name -> Type -> IdInfo -> Id
306 = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
307 varDetails = AnId, varInfo = info}
312 isId (Var {varDetails = AnId}) = True
316 @externallyVisibleId@: is it true that another module might be
317 able to ``see'' this Id in a code generation sense. That
318 is, another .o file might refer to this Id.
320 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
321 local-ness precisely so that the test here would be easy
323 This defn appears here (rather than, say, in Id.lhs) because
324 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
328 externallyVisibleId :: Id -> Bool
329 externallyVisibleId var = isExternallyVisibleName (varName var)