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,
22 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
23 setIdName, setIdUnique, setIdInfo, lazySetIdInfo, zapIdInfo,
24 mkIdVar, isId, externallyVisibleId
27 #include "HsVersions.h"
29 import {-# SOURCE #-} TypeRep( Type, Kind )
30 import {-# SOURCE #-} IdInfo( IdInfo, seqIdInfo, vanillaIdInfo )
32 import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
33 import Name ( Name, OccName, NamedThing(..),
34 setNameUnique, setNameOcc, nameUnique,
35 mkSysLocalName, isExternallyVisibleName
40 import IOExts ( IORef, newIORef, readIORef, writeIORef )
44 %************************************************************************
46 \subsection{The main data type declarations}
48 %************************************************************************
51 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
52 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
53 strictness). The essential info about different kinds of @Vars@ is
60 realUnique :: FastInt, -- Key for fast comparison
61 -- Identical to the Unique in the name,
62 -- cached here for speed
64 varDetails :: VarDetails,
65 varInfo :: IdInfo -- Only used for Ids at the moment
71 | MutTyVar (IORef (Maybe Type)) -- Used during unification;
72 Bool -- True <=> this is a type signature variable, which
73 -- should not be unified with a non-tyvar type
75 -- For a long time I tried to keep mutable Vars statically type-distinct
76 -- from immutable Vars, but I've finally given up. It's just too painful.
77 -- After type checking there are no MutTyVars left, but there's no static check
82 instance Outputable Var where
83 ppr var = ppr (varName var)
85 instance Show Var where
86 showsPrec p var = showsPrecSDoc p (ppr var)
88 instance NamedThing Var where
91 instance Uniquable Var where
95 a == b = realUnique a ==# realUnique b
97 instance Ord Var where
98 a <= b = realUnique a <=# realUnique b
99 a < b = realUnique a <# realUnique b
100 a >= b = realUnique a >=# realUnique b
101 a > b = realUnique a ># realUnique b
102 a `compare` b = varUnique a `compare` varUnique b
107 varUnique :: Var -> Unique
108 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
110 setVarUnique :: Var -> Unique -> Var
111 setVarUnique var@(Var {varName = name}) uniq
112 = var {realUnique = getKey uniq,
113 varName = setNameUnique name uniq}
115 setVarName :: Var -> Name -> Var
116 setVarName var new_name
117 = var { realUnique = getKey (getUnique new_name), varName = new_name }
119 setVarOcc :: Var -> OccName -> Var
120 setVarOcc var new_occ
121 = var { varName = setNameOcc (varName var) new_occ }
123 setVarType :: Var -> Type -> Var
124 setVarType var ty = var {varType = ty}
128 %************************************************************************
130 \subsection{Type variables}
132 %************************************************************************
142 setTyVarUnique = setVarUnique
143 setTyVarName = setVarName
147 mkTyVar :: Name -> Kind -> TyVar
148 mkTyVar name kind = Var { varName = name
149 , realUnique = getKey (nameUnique name)
152 , varInfo = pprPanic "mkTyVar" (ppr name)
155 mkSysTyVar :: Unique -> Kind -> TyVar
156 mkSysTyVar uniq kind = Var { varName = name
157 , realUnique = getKey uniq
160 , varInfo = pprPanic "mkSysTyVar" (ppr name)
163 name = mkSysLocalName uniq SLIT("t")
165 newMutTyVar :: Name -> Kind -> IO TyVar
166 newMutTyVar name kind = newTyVar name kind False
168 newSigTyVar :: Name -> Kind -> IO TyVar
169 -- Type variables from type signatures are still mutable, because
170 -- they may get unified with type variables from other signatures
171 -- But they do contain a flag to distinguish them, so we can tell if
172 -- we unify them with a non-type-variable.
173 newSigTyVar name kind = newTyVar name kind True
175 newTyVar name kind is_sig
176 = do loc <- newIORef Nothing
177 return (Var { varName = name
178 , realUnique = getKey (nameUnique name)
180 , varDetails = MutTyVar loc is_sig
181 , varInfo = pprPanic "newMutTyVar" (ppr name)
184 readMutTyVar :: TyVar -> IO (Maybe Type)
185 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
187 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
188 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
190 makeTyVarImmutable :: TyVar -> TyVar
191 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
193 isTyVar :: Var -> Bool
194 isTyVar (Var {varDetails = details}) = case details of
199 isMutTyVar :: Var -> Bool
200 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
201 isMutTyVar other = False
203 isSigTyVar :: Var -> Bool
204 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
205 isSigTyVar other = False
209 %************************************************************************
211 \subsection{Id Construction}
213 %************************************************************************
215 Most Id-related functions are in Id.lhs and MkId.lhs
228 setIdUnique :: Id -> Unique -> Id
229 setIdUnique = setVarUnique
231 setIdName :: Id -> Name -> Id
232 setIdName = setVarName
234 lazySetIdInfo :: Id -> IdInfo -> Id
235 lazySetIdInfo var info = var {varInfo = info}
237 setIdInfo :: Id -> IdInfo -> Id
238 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
239 -- Try to avoid spack leaks by seq'ing
241 zapIdInfo :: Id -> Id
242 zapIdInfo var = var {varInfo = vanillaIdInfo}
244 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
245 modifyIdInfo fn var@(Var {varInfo = info})
246 = seqIdInfo new_info `seq` var {varInfo = new_info}
250 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
251 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
252 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
254 Just new_info -> var {varInfo = new_info}
258 mkIdVar :: Name -> Type -> IdInfo -> Id
260 = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
261 varDetails = AnId, varInfo = info}
266 isId (Var {varDetails = AnId}) = True
270 @externallyVisibleId@: is it true that another module might be
271 able to ``see'' this Id in a code generation sense. That
272 is, another .o file might refer to this Id.
274 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
275 local-ness precisely so that the test here would be easy
277 This defn appears here (rather than, say, in Id.lhs) because
278 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
282 externallyVisibleId :: Id -> Bool
283 externallyVisibleId var = isExternallyVisibleName (varName var)