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,
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
67 realUnique :: Int#, -- Key for fast comparison
68 -- Identical to the Unique in the name,
69 -- cached here for speed
71 varDetails :: VarDetails,
72 varInfo :: IdInfo -- Only used for Ids at the moment
78 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
79 Bool -- True <=> this is a type signature variable, which
80 -- should not be unified with a non-tyvar type
81 | UVar -- Usage variable
83 -- For a long time I tried to keep mutable Vars statically type-distinct
84 -- from immutable Vars, but I've finally given up. It's just too painful.
85 -- After type checking there are no MutTyVars left, but there's no static check
90 instance Outputable Var where
91 ppr var = ppr (varName var)
93 instance Show Var where
94 showsPrec p var = showsPrecSDoc p (ppr var)
96 instance NamedThing Var where
99 instance Uniquable Var where
100 getUnique = varUnique
102 instance Eq Var where
103 a == b = realUnique a ==# realUnique b
105 instance Ord Var where
106 a <= b = realUnique a <=# realUnique b
107 a < b = realUnique a <# realUnique b
108 a >= b = realUnique a >=# realUnique b
109 a > b = realUnique a ># realUnique b
110 a `compare` b = varUnique a `compare` varUnique b
115 varUnique :: Var -> Unique
116 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
118 setVarUnique :: Var -> Unique -> Var
119 setVarUnique var@(Var {varName = name}) uniq
120 = var {realUnique = getKey uniq,
121 varName = setNameUnique name uniq}
123 setVarName :: Var -> Name -> Var
124 setVarName var new_name
125 = var { realUnique = getKey (getUnique new_name), varName = new_name }
127 setVarOcc :: Var -> OccName -> Var
128 setVarOcc var new_occ
129 = var { varName = setNameOcc (varName var) new_occ }
131 setVarType :: Var -> Type -> Var
132 setVarType var ty = var {varType = ty}
136 %************************************************************************
138 \subsection{Type variables}
140 %************************************************************************
150 setTyVarUnique = setVarUnique
151 setTyVarName = setVarName
155 mkTyVar :: Name -> Kind -> TyVar
156 mkTyVar name kind = Var { varName = name
157 , realUnique = getKey (nameUnique name)
161 , varInfo = pprPanic "looking at IdInfo of a tyvar" (ppr name)
165 mkSysTyVar :: Unique -> Kind -> TyVar
166 mkSysTyVar uniq kind = Var { varName = name
167 , realUnique = getKey uniq
171 , varInfo = pprPanic "mkSysTyVar" (ppr name)
175 name = mkSysLocalName uniq SLIT("t")
177 newMutTyVar :: Name -> Kind -> IO TyVar
178 newMutTyVar name kind =
179 do loc <- newIORef Nothing
180 return (Var { varName = name,
181 realUnique = getKey (nameUnique name),
183 varDetails = MutTyVar loc False})
185 newSigTyVar :: Name -> Kind -> IO TyVar
186 newSigTyVar name kind =
187 do loc <- newIORef Nothing
188 return (Var { varName = name,
189 realUnique = getKey (nameUnique name),
191 varDetails = MutTyVar loc True})
193 readMutTyVar :: TyVar -> IO (Maybe Type)
194 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
196 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
197 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
199 makeTyVarImmutable :: TyVar -> TyVar
200 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
202 isTyVar :: Var -> Bool
203 isTyVar (Var {varDetails = details}) = case details of
208 isMutTyVar :: Var -> Bool
209 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
210 isMutTyVar other = False
212 isSigTyVar :: Var -> Bool
213 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
214 isSigTyVar other = False
218 %************************************************************************
220 \subsection{Usage variables}
222 %************************************************************************
229 mkUVar :: Unique -> UVar
230 mkUVar unique = Var { varName = mkSysLocalName unique SLIT("u"),
231 realUnique = getKey unique,
234 mkNamedUVar :: Name -> UVar
235 mkNamedUVar name = Var { varName = name
236 , realUnique = getKey (nameUnique name)
239 , varType = pprPanic "looking at Type of a uvar" (ppr name)
240 , varInfo = pprPanic "looking at IdInfo of a uvar" (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)