2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section{@Vars@: Variables}
10 varName, varUnique, varType,
11 setVarName, setVarUnique,
14 TyVar, mkTyVar, mkTcTyVar, mkWildCoVar,
16 setTyVarName, setTyVarUnique, setTyVarKind,
20 CoVar, coVarName, setCoVarUnique, setCoVarName, mkCoVar, isCoVar,
24 idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
25 setIdName, setIdUnique, setIdType, setIdInfo, lazySetIdInfo,
26 setIdExported, setIdNotExported,
28 globalIdDetails, globaliseId,
30 mkLocalId, mkExportedLocalId, mkGlobalId,
32 isTyVar, isTcTyVar, isId, isLocalVar, isLocalId,
33 isGlobalId, isExportedId,
37 #include "HsVersions.h"
39 import {-# SOURCE #-} TypeRep( Type, Kind )
40 import {-# SOURCE #-} TcType( TcTyVarDetails, pprTcTyVarDetails )
41 import {-# SOURCE #-} IdInfo( GlobalIdDetails, notGlobalId,
43 import {-# SOURCE #-} TypeRep( isCoercionKind )
45 import Name hiding (varName)
53 %************************************************************************
55 \subsection{The main data type declarations}
57 %************************************************************************
60 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
61 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
62 strictness). The essential info about different kinds of @Vars@ is
69 realUnique :: FastInt, -- Key for fast comparison
70 -- Identical to the Unique in the name,
71 -- cached here for speed
76 | TcTyVar { -- Used only during type inference
77 -- Used for kind variables during
80 realUnique :: FastInt,
82 tcTyVarDetails :: TcTyVarDetails }
84 | GlobalId { -- Used for imported Ids, dict selectors etc
85 -- See Note [GlobalId/LocalId] below
86 varName :: !Name, -- Always an External or WiredIn Name
87 realUnique :: FastInt,
90 gblDetails :: GlobalIdDetails }
92 | LocalId { -- Used for locally-defined Ids
93 -- See Note [GlobalId/LocalId] below
95 realUnique :: FastInt,
98 lclDetails :: LocalIdDetails }
101 = NotExported -- Not exported
102 | Exported -- Exported
103 -- Exported Ids are kept alive;
104 -- NotExported things may be discarded as dead code.
107 Note [GlobalId/LocalId]
108 ~~~~~~~~~~~~~~~~~~~~~~~
110 * always a constant (top-level)
111 * imported, or data constructor, or primop, or record selector
112 * has a Unique that is globally unique across the whole
113 GHC invocation (a single invocation may compile multiple modules)
114 * never treated as a candidate by the free-variable finder;
118 * bound within an expression (lambda, case, local let(rec))
119 * or defined at top level in the module being compiled
120 * always treated as a candidate by the free-variable finder
122 After CoreTidy, top-level LocalIds are turned into GlobalIds
126 instance Outputable Var where
127 ppr var = ppr (varName var) <+> ifPprDebug (brackets extra)
130 GlobalId {} -> ptext (sLit "gid")
131 LocalId {} -> ptext (sLit "lid")
132 TyVar {} -> ptext (sLit "tv")
133 TcTyVar {tcTyVarDetails = details} -> pprTcTyVarDetails details
135 instance Show Var where
136 showsPrec p var = showsPrecSDoc p (ppr var)
138 instance NamedThing Var where
141 instance Uniquable Var where
142 getUnique = varUnique
144 instance Eq Var where
145 a == b = realUnique a ==# realUnique b
147 instance Ord Var where
148 a <= b = realUnique a <=# realUnique b
149 a < b = realUnique a <# realUnique b
150 a >= b = realUnique a >=# realUnique b
151 a > b = realUnique a ># realUnique b
152 a `compare` b = varUnique a `compare` varUnique b
157 varUnique :: Var -> Unique
158 varUnique var = mkUniqueGrimily (iBox (realUnique var))
160 setVarUnique :: Var -> Unique -> Var
161 setVarUnique var uniq
162 = var { realUnique = getKeyFastInt uniq,
163 varName = setNameUnique (varName var) uniq }
165 setVarName :: Var -> Name -> Var
166 setVarName var new_name
167 = var { realUnique = getKeyFastInt (getUnique new_name),
172 %************************************************************************
174 \subsection{Type variables}
176 %************************************************************************
181 tyVarName :: TyVar -> Name
184 tyVarKind :: TyVar -> Kind
187 setTyVarUnique :: TyVar -> Unique -> TyVar
188 setTyVarUnique = setVarUnique
190 setTyVarName :: TyVar -> Name -> TyVar
191 setTyVarName = setVarName
193 setTyVarKind :: TyVar -> Kind -> TyVar
194 setTyVarKind tv k = tv {varType = k}
198 mkTyVar :: Name -> Kind -> TyVar
199 mkTyVar name kind = ASSERT( not (isCoercionKind kind ) )
200 TyVar { varName = name
201 , realUnique = getKeyFastInt (nameUnique name)
203 , isCoercionVar = False
206 mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
207 mkTcTyVar name kind details
208 = -- TOM: no longer valid assertion?
209 -- ASSERT( not (isCoercionKind kind) )
210 TcTyVar { varName = name,
211 realUnique = getKeyFastInt (nameUnique name),
213 tcTyVarDetails = details
217 %************************************************************************
219 \subsection{Coercion variables}
221 %************************************************************************
224 type CoVar = Var -- A coercion variable is simply a type
225 -- variable of kind (ty1 :=: ty2)
227 coVarName :: CoVar -> Name
230 setCoVarUnique :: CoVar -> Unique -> CoVar
231 setCoVarUnique = setVarUnique
233 setCoVarName :: CoVar -> Name -> CoVar
234 setCoVarName = setVarName
236 mkCoVar :: Name -> Kind -> CoVar
237 mkCoVar name kind = ASSERT( isCoercionKind kind )
238 TyVar { varName = name
239 , realUnique = getKeyFastInt (nameUnique name)
241 -- varType is always PredTy (EqPred t1 t2)
242 , isCoercionVar = True
245 mkWildCoVar :: Kind -> TyVar
246 -- A type variable that is never referred to,
247 -- so its unique doesn't matter
249 = ASSERT( isCoercionKind kind )
250 TyVar { varName = mkSysTvName wild_uniq (fsLit "co_wild"),
251 realUnique = _ILIT(1),
253 isCoercionVar = True }
255 wild_uniq = mkBuiltinUnique 1
258 %************************************************************************
260 \subsection{Id Construction}
262 %************************************************************************
264 Most Id-related functions are in Id.lhs and MkId.lhs
273 idUnique :: Id -> Unique
280 setIdUnique :: Id -> Unique -> Id
281 setIdUnique = setVarUnique
283 setIdName :: Id -> Name -> Id
284 setIdName = setVarName
286 setIdType :: Id -> Type -> Id
287 setIdType id ty = id {varType = ty}
289 setIdExported :: Id -> Id
290 -- Can be called on GlobalIds, such as data cons and class ops,
291 -- which are "born" as GlobalIds and automatically exported
292 setIdExported id@(LocalId {}) = id { lclDetails = Exported }
293 setIdExported other_id = ASSERT( isId other_id ) other_id
295 setIdNotExported :: Id -> Id
296 -- We can only do this to LocalIds
297 setIdNotExported id = ASSERT( isLocalId id ) id { lclDetails = NotExported }
299 globaliseId :: GlobalIdDetails -> Id -> Id
300 -- If it's a local, make it global
301 globaliseId details id = GlobalId { varName = varName id,
302 realUnique = realUnique id,
303 varType = varType id,
305 gblDetails = details }
307 idInfo :: Id -> IdInfo
308 idInfo (GlobalId {idInfo_ = info}) = info
309 idInfo (LocalId {idInfo_ = info}) = info
310 idInfo other_var = pprPanic "idInfo" (ppr other_var)
312 lazySetIdInfo :: Id -> IdInfo -> Id
313 lazySetIdInfo id info = id {idInfo_ = info}
315 setIdInfo :: Id -> IdInfo -> Id
316 setIdInfo id info = seqIdInfo info `seq` id {idInfo_ = info}
317 -- Try to avoid spack leaks by seq'ing
319 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
321 = seqIdInfo new_info `seq` id {idInfo_ = new_info}
323 new_info = fn (idInfo id)
325 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
326 maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
327 maybeModifyIdInfo (Just new_info) id = id {idInfo_ = new_info}
328 maybeModifyIdInfo Nothing id = id
331 %************************************************************************
333 \subsection{Predicates over variables
335 %************************************************************************
338 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
339 mkGlobalId details name ty info
340 = GlobalId { varName = name,
341 realUnique = getKeyFastInt (nameUnique name), -- Cache the unique
343 gblDetails = details,
346 mk_local_id :: Name -> Type -> LocalIdDetails -> IdInfo -> Id
347 mk_local_id name ty details info
348 = LocalId { varName = name,
349 realUnique = getKeyFastInt (nameUnique name), -- Cache the unique
351 lclDetails = details,
354 mkLocalId :: Name -> Type -> IdInfo -> Id
355 mkLocalId name ty info = mk_local_id name ty NotExported info
357 mkExportedLocalId :: Name -> Type -> IdInfo -> Id
358 mkExportedLocalId name ty info = mk_local_id name ty Exported info
362 isTyVar, isTcTyVar :: Var -> Bool
363 isId, isLocalVar, isLocalId :: Var -> Bool
364 isGlobalId, isExportedId :: Var -> Bool
365 mustHaveLocalBinding :: Var -> Bool
366 isCoVar :: Var -> Bool
368 isTyVar (TyVar {}) = True
369 isTyVar (TcTyVar {}) = True
372 isTcTyVar (TcTyVar {}) = True
375 isId (LocalId {}) = True
376 isId (GlobalId {}) = True
379 isLocalId (LocalId {}) = True
382 isCoVar (v@(TyVar {})) = isCoercionVar v
385 -- isLocalVar returns True for type variables as well as local Ids
386 -- These are the variables that we need to pay attention to when finding free
387 -- variables, or doing dependency analysis.
388 isLocalVar (GlobalId {}) = False
391 -- mustHaveLocalBinding returns True of Ids and TyVars
392 -- that must have a binding in this module. The converse
393 -- is not quite right: there are some GlobalIds that must have
394 -- bindings, such as record selectors. But that doesn't matter,
395 -- because it's only used for assertions
396 mustHaveLocalBinding var = isLocalVar var
398 isGlobalId (GlobalId {}) = True
401 -- isExportedId means "don't throw this away"
402 isExportedId (GlobalId {}) = True
403 isExportedId (LocalId {lclDetails = details})
407 isExportedId _ = False
411 globalIdDetails :: Var -> GlobalIdDetails
412 -- Works OK on local Ids too, returning notGlobalId
413 globalIdDetails (GlobalId {gblDetails = details}) = details
414 globalIdDetails _ = notGlobalId