2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Id]{@Ids@: Value and constructor identifiers}
10 -- Simple construction
11 mkId, mkVanillaId, mkSysLocal, mkUserLocal,
12 mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
15 idName, idType, idUnique, idInfo,
17 recordSelectorFieldLabel,
20 setIdName, setIdUnique, setIdType, setIdNoDiscard,
21 setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
22 zapFragileIdInfo, zapLamIdInfo,
25 omitIfaceSigForId, isDeadBinder,
26 exportWithOrigOccName,
30 isSpecPragmaId, isRecordSelector,
31 isPrimOpId, isPrimOpId_maybe,
32 isDataConId, isDataConId_maybe, isDataConWrapId,
33 isDataConWrapId_maybe,
35 isExportedId, isUserExportedId,
38 -- Inline pragma stuff
39 idInlinePragma, setInlinePragma, modifyInlinePragma,
42 -- One shot lambda stuff
43 isOneShotLambda, setOneShotLambda, clearOneShotLambda,
70 #include "HsVersions.h"
73 import CoreSyn ( Unfolding, CoreRules )
74 import BasicTypes ( Arity )
75 import Var ( Id, DictId,
77 idName, idType, idUnique, idInfo,
78 setIdName, setVarType, setIdUnique,
79 setIdInfo, lazySetIdInfo, modifyIdInfo,
84 import Type ( Type, tyVarsOfType, typePrimRep, addFreeTyVars,
85 seqType, splitTyConApp_maybe )
89 import Demand ( Demand )
90 import Name ( Name, OccName,
91 mkSysLocalName, mkLocalName,
92 isUserExportedName, getOccName, isIPOcc
94 import OccName ( UserFS )
95 import PrimRep ( PrimRep )
96 import TysPrim ( statePrimTyCon )
97 import FieldLabel ( FieldLabel )
98 import SrcLoc ( SrcLoc )
99 import Unique ( Unique, mkBuiltinUnique, getBuiltinUniques,
100 getNumBuiltinUniques )
102 infixl 1 `setIdUnfolding`,
107 `setIdSpecialisation`,
112 -- infixl so you can say (id `set` a `set` b)
117 %************************************************************************
119 \subsection{Simple Id construction}
121 %************************************************************************
123 Absolutely all Ids are made by mkId. It
124 a) Pins free-tyvar-info onto the Id's type,
125 where it can easily be found.
126 b) Ensures that exported Ids are
129 mkId :: Name -> Type -> IdInfo -> Id
130 mkId name ty info = mkIdVar name (addFreeTyVars ty) info'
132 info' | isUserExportedName name = setNoDiscardInfo info
137 mkVanillaId :: Name -> Type -> Id
138 mkVanillaId name ty = mkId name ty vanillaIdInfo
140 -- SysLocal: for an Id being created by the compiler out of thin air...
141 -- UserLocal: an Id with a name the user might recognize...
142 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
143 mkSysLocal :: UserFS -> Unique -> Type -> Id
145 mkSysLocal fs uniq ty = mkVanillaId (mkSysLocalName uniq fs) ty
146 mkUserLocal occ uniq ty loc = mkVanillaId (mkLocalName uniq occ loc) ty
149 Make some local @Ids@ for a template @CoreExpr@. These have bogus
150 @Uniques@, but that's OK because the templates are supposed to be
151 instantiated before use.
154 -- "Wild Id" typically used when you need a binder that you don't expect to use
155 mkWildId :: Type -> Id
156 mkWildId ty = mkSysLocal SLIT("wild") (mkBuiltinUnique 1) ty
158 -- "Template locals" typically used in unfoldings
159 mkTemplateLocals :: [Type] -> [Id]
160 mkTemplateLocals tys = zipWith (mkSysLocal SLIT("tpl"))
161 (getBuiltinUniques (length tys))
164 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
165 mkTemplateLocalsNum n tys = zipWith (mkSysLocal SLIT("tpl"))
166 (getNumBuiltinUniques n (length tys))
169 mkTemplateLocal :: Int -> Type -> Id
170 mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
174 %************************************************************************
176 \subsection[Id-general-funs]{General @Id@-related functions}
178 %************************************************************************
181 idFreeTyVars :: Id -> TyVarSet
182 idFreeTyVars id = tyVarsOfType (idType id)
184 setIdType :: Id -> Type -> Id
185 -- Add free tyvar info to the type
186 setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
188 idPrimRep :: Id -> PrimRep
189 idPrimRep id = typePrimRep (idType id)
193 %************************************************************************
195 \subsection{Special Ids}
197 %************************************************************************
200 idFlavour :: Id -> IdFlavour
201 idFlavour id = flavourInfo (idInfo id)
203 setIdNoDiscard :: Id -> Id
204 setIdNoDiscard id -- Make an Id into a NoDiscardId, unless it is already
205 = modifyIdInfo setNoDiscardInfo id
207 recordSelectorFieldLabel :: Id -> FieldLabel
208 recordSelectorFieldLabel id = case idFlavour id of
209 RecordSelId lbl -> lbl
211 isRecordSelector id = case idFlavour id of
212 RecordSelId lbl -> True
215 isPrimOpId id = case idFlavour id of
219 isPrimOpId_maybe id = case idFlavour id of
220 PrimOpId op -> Just op
223 isDataConId id = case idFlavour id of
227 isDataConId_maybe id = case idFlavour id of
228 DataConId con -> Just con
231 isDataConWrapId_maybe id = case idFlavour id of
232 DataConWrapId con -> Just con
235 isDataConWrapId id = case idFlavour id of
236 DataConWrapId con -> True
239 isSpecPragmaId id = case idFlavour id of
243 hasNoBinding id = case idFlavour id of
247 -- hasNoBinding returns True of an Id which may not have a
248 -- binding, even though it is defined in this module. Notably,
249 -- the constructors of a dictionary are in this situation.
251 -- Don't drop a binding for an exported Id,
252 -- if it otherwise looks dead.
253 isExportedId :: Id -> Bool
254 isExportedId id = case idFlavour id of
256 other -> True -- All the others are no-discard
258 -- Say if an Id was exported by the user
259 -- Implies isExportedId (see mkId above)
260 isUserExportedId :: Id -> Bool
261 isUserExportedId id = isUserExportedName (idName id)
265 omitIfaceSigForId tells whether an Id's info is implied by other declarations,
266 so we don't need to put its signature in an interface file, even if it's mentioned
267 in some other interface unfolding.
270 omitIfaceSigForId :: Id -> Bool
273 = case idFlavour id of
274 RecordSelId _ -> True -- Includes dictionary selectors
277 DataConWrapId _ -> True
278 -- These are are implied by their type or class decl;
279 -- remember that all type and class decls appear in the interface file.
280 -- The dfun id must *not* be omitted, because it carries version info for
283 other -> False -- Don't omit!
285 -- Certain names must be exported with their original occ names, because
286 -- these names are bound by either a class declaration or a data declaration
287 -- or an explicit user export.
288 exportWithOrigOccName :: Id -> Bool
289 exportWithOrigOccName id = omitIfaceSigForId id || isUserExportedId id
293 isDeadBinder :: Id -> Bool
294 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
295 | otherwise = False -- TyVars count as not dead
297 isIP id = isIPOcc (getOccName id)
301 %************************************************************************
303 \subsection{IdInfo stuff}
305 %************************************************************************
308 ---------------------------------
310 idArityInfo :: Id -> ArityInfo
311 idArityInfo id = arityInfo (idInfo id)
313 idArity :: Id -> Arity
314 idArity id = arityLowerBound (idArityInfo id)
316 setIdArityInfo :: Id -> ArityInfo -> Id
317 setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
319 ---------------------------------
321 idStrictness :: Id -> StrictnessInfo
322 idStrictness id = strictnessInfo (idInfo id)
324 setIdStrictness :: Id -> StrictnessInfo -> Id
325 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
327 -- isBottomingId returns true if an application to n args would diverge
328 isBottomingId :: Id -> Bool
329 isBottomingId id = isBottomingStrictness (idStrictness id)
331 ---------------------------------
333 idWorkerInfo :: Id -> WorkerInfo
334 idWorkerInfo id = workerInfo (idInfo id)
336 setIdWorkerInfo :: Id -> WorkerInfo -> Id
337 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
339 ---------------------------------
341 idUnfolding :: Id -> Unfolding
342 idUnfolding id = unfoldingInfo (idInfo id)
344 setIdUnfolding :: Id -> Unfolding -> Id
345 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
347 ---------------------------------
349 idDemandInfo :: Id -> Demand
350 idDemandInfo id = demandInfo (idInfo id)
352 setIdDemandInfo :: Id -> Demand -> Id
353 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
355 ---------------------------------
357 idSpecialisation :: Id -> CoreRules
358 idSpecialisation id = specInfo (idInfo id)
360 setIdSpecialisation :: Id -> CoreRules -> Id
361 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
363 ---------------------------------
365 idCafInfo :: Id -> CafInfo
366 idCafInfo id = cafInfo (idInfo id)
368 setIdCafInfo :: Id -> CafInfo -> Id
369 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
371 ---------------------------------
373 idCprInfo :: Id -> CprInfo
374 idCprInfo id = cprInfo (idInfo id)
376 setIdCprInfo :: Id -> CprInfo -> Id
377 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
379 ---------------------------------
381 idOccInfo :: Id -> OccInfo
382 idOccInfo id = occInfo (idInfo id)
384 setIdOccInfo :: Id -> OccInfo -> Id
385 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
389 ---------------------------------
391 The inline pragma tells us to be very keen to inline this Id, but it's still
392 OK not to if optimisation is switched off.
395 idInlinePragma :: Id -> InlinePragInfo
396 idInlinePragma id = inlinePragInfo (idInfo id)
398 setInlinePragma :: Id -> InlinePragInfo -> Id
399 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
401 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
402 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
406 ---------------------------------
409 idLBVarInfo :: Id -> LBVarInfo
410 idLBVarInfo id = lbvarInfo (idInfo id)
412 isOneShotLambda :: Id -> Bool
413 isOneShotLambda id = case idLBVarInfo id of
414 IsOneShotLambda -> True
415 NoLBVarInfo -> case splitTyConApp_maybe (idType id) of
416 Just (tycon,_) -> tycon == statePrimTyCon
418 -- The last clause is a gross hack. It claims that
419 -- every function over realWorldStatePrimTy is a one-shot
420 -- function. This is pretty true in practice, and makes a big
421 -- difference. For example, consider
422 -- a `thenST` \ r -> ...E...
423 -- The early full laziness pass, if it doesn't know that r is one-shot
424 -- will pull out E (let's say it doesn't mention r) to give
425 -- let lvl = E in a `thenST` \ r -> ...lvl...
426 -- When `thenST` gets inlined, we end up with
427 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
428 -- and we don't re-inline E.
430 -- It would be better to spot that r was one-shot to start with, but
431 -- I don't want to rely on that.
433 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
434 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
436 setOneShotLambda :: Id -> Id
437 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
439 clearOneShotLambda :: Id -> Id
440 clearOneShotLambda id
441 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
444 -- But watch out: this may change the type of something else
446 -- If we change the one-shot-ness of x, f's type changes
450 zapFragileIdInfo :: Id -> Id
451 zapFragileIdInfo id = maybeModifyIdInfo zapFragileInfo id
453 zapLamIdInfo :: Id -> Id
454 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id