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,
30 mkIdVar, isId, externallyVisibleId
33 #include "HsVersions.h"
35 import {-# SOURCE #-} Type( Type, Kind )
36 import {-# SOURCE #-} IdInfo( IdInfo, seqIdInfo )
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,
238 isUVar :: Var -> Bool
239 isUVar (Var {varDetails = details}) = case details of
245 %************************************************************************
247 \subsection{Id Construction}
249 %************************************************************************
251 Most Id-related functions are in Id.lhs and MkId.lhs
264 setIdUnique :: Id -> Unique -> Id
265 setIdUnique = setVarUnique
267 setIdName :: Id -> Name -> Id
268 setIdName = setVarName
270 lazySetIdInfo :: Id -> IdInfo -> Id
271 lazySetIdInfo var info = var {varInfo = info}
273 setIdInfo :: Id -> IdInfo -> Id
274 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
275 -- Try to avoid spack leaks by seq'ing
277 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
278 modifyIdInfo fn var@(Var {varInfo = info})
279 = seqIdInfo new_info `seq` var {varInfo = new_info}
283 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
284 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
285 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
287 Just new_info -> var {varInfo = new_info}
291 mkIdVar :: Name -> Type -> IdInfo -> Id
293 = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
294 varDetails = AnId, varInfo = info}
299 isId (Var {varDetails = AnId}) = True
303 @externallyVisibleId@: is it true that another module might be
304 able to ``see'' this Id in a code generation sense. That
305 is, another .o file might refer to this Id.
307 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
308 local-ness precisely so that the test here would be easy
310 This defn appears here (rather than, say, in Id.lhs) because
311 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
315 externallyVisibleId :: Id -> Bool
316 externallyVisibleId var = isExternallyVisibleName (varName var)