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 isImplicitId, isDeadBinder,
28 isSpecPragmaId, isRecordSelector,
29 isPrimOpId, isPrimOpId_maybe, isDictFunId,
30 isDataConId, isDataConId_maybe,
31 isDataConWrapId, isDataConWrapId_maybe,
33 isExportedId, isLocalId,
36 -- Inline pragma stuff
37 idInlinePragma, setInlinePragma, modifyInlinePragma,
40 -- One shot lambda stuff
41 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,
83 import Type ( Type, typePrimRep, addFreeTyVars,
84 usOnce, seqType, splitTyConApp_maybe )
88 import Demand ( Demand )
89 import Name ( Name, OccName,
90 mkSysLocalName, mkLocalName,
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 )
103 infixl 1 `setIdUnfolding`,
109 `setIdSpecialisation`,
114 -- infixl so you can say (id `set` a `set` b)
119 %************************************************************************
121 \subsection{Simple Id construction}
123 %************************************************************************
125 Absolutely all Ids are made by mkId. It
126 a) Pins free-tyvar-info onto the Id's type,
127 where it can easily be found.
128 b) Ensures that exported Ids are
131 mkId :: Name -> Type -> IdInfo -> Id
132 mkId name ty info = mkIdVar name (addFreeTyVars ty) info
136 mkVanillaId :: Name -> Type -> Id
137 mkVanillaId name ty = mkId name ty vanillaIdInfo
139 -- SysLocal: for an Id being created by the compiler out of thin air...
140 -- UserLocal: an Id with a name the user might recognize...
141 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
142 mkSysLocal :: UserFS -> Unique -> Type -> Id
144 mkSysLocal fs uniq ty = mkVanillaId (mkSysLocalName uniq fs) ty
145 mkUserLocal occ uniq ty loc = mkVanillaId (mkLocalName uniq occ loc) ty
148 Make some local @Ids@ for a template @CoreExpr@. These have bogus
149 @Uniques@, but that's OK because the templates are supposed to be
150 instantiated before use.
153 -- "Wild Id" typically used when you need a binder that you don't expect to use
154 mkWildId :: Type -> Id
155 mkWildId ty = mkSysLocal SLIT("wild") (mkBuiltinUnique 1) ty
157 -- "Template locals" typically used in unfoldings
158 mkTemplateLocals :: [Type] -> [Id]
159 mkTemplateLocals tys = zipWith (mkSysLocal SLIT("tpl"))
160 (getBuiltinUniques (length tys))
163 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
164 mkTemplateLocalsNum n tys = zipWith (mkSysLocal SLIT("tpl"))
165 (getNumBuiltinUniques n (length tys))
168 mkTemplateLocal :: Int -> Type -> Id
169 mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
173 %************************************************************************
175 \subsection[Id-general-funs]{General @Id@-related functions}
177 %************************************************************************
180 setIdType :: Id -> Type -> Id
181 -- Add free tyvar info to the type
182 setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
184 idPrimRep :: Id -> PrimRep
185 idPrimRep id = typePrimRep (idType id)
189 %************************************************************************
191 \subsection{Special Ids}
193 %************************************************************************
196 idFlavour :: Id -> IdFlavour
197 idFlavour id = flavourInfo (idInfo id)
199 setIdNoDiscard :: Id -> Id
200 setIdNoDiscard id -- Make an Id into a NoDiscardId, unless it is already
201 = modifyIdInfo setNoDiscardInfo id
203 recordSelectorFieldLabel :: Id -> FieldLabel
204 recordSelectorFieldLabel id = case idFlavour id of
205 RecordSelId lbl -> lbl
207 isRecordSelector id = case idFlavour id of
208 RecordSelId lbl -> True
211 isPrimOpId id = case idFlavour id of
215 isPrimOpId_maybe id = case idFlavour id of
216 PrimOpId op -> Just op
219 isDataConId id = case idFlavour id of
223 isDataConId_maybe id = case idFlavour id of
224 DataConId con -> Just con
227 isDataConWrapId_maybe id = case idFlavour id of
228 DataConWrapId con -> Just con
231 isDataConWrapId id = case idFlavour id of
232 DataConWrapId con -> True
235 isSpecPragmaId id = case idFlavour id of
239 hasNoBinding id = case idFlavour id of
243 -- hasNoBinding returns True of an Id which may not have a
244 -- binding, even though it is defined in this module. Notably,
245 -- the constructors of a dictionary are in this situation.
247 isDictFunId id = case idFlavour id of
251 -- Don't drop a binding for an exported Id,
252 -- if it otherwise looks dead.
253 -- Perhaps a better name would be isDiscardableId
254 isExportedId :: Id -> Bool
255 isExportedId id = case idFlavour id of
259 isLocalId :: Id -> Bool
260 -- True of Ids that are locally defined, but are not constants
261 -- like data constructors, record selectors, and the like.
262 -- See comments with CoreFVs.isLocalVar
265 | not (isId id) = pprTrace "isLocalid" (ppr id) False
268 = case idFlavour id of
276 isImplicitId tells whether an Id's info is implied by other
277 declarations, so we don't need to put its signature in an interface
278 file, even if it's mentioned in some other interface unfolding.
281 isImplicitId :: Id -> Bool
283 = case idFlavour id of
284 RecordSelId _ -> True -- Includes dictionary selectors
287 DataConWrapId _ -> True
288 -- These are are implied by their type or class decl;
289 -- remember that all type and class decls appear in the interface file.
290 -- The dfun id must *not* be omitted, because it carries version info for
296 isDeadBinder :: Id -> Bool
297 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
298 | otherwise = False -- TyVars count as not dead
300 isIP id = isIPOcc (getOccName id)
304 %************************************************************************
306 \subsection{IdInfo stuff}
308 %************************************************************************
311 ---------------------------------
313 idArityInfo :: Id -> ArityInfo
314 idArityInfo id = arityInfo (idInfo id)
316 idArity :: Id -> Arity
317 idArity id = arityLowerBound (idArityInfo id)
319 setIdArityInfo :: Id -> ArityInfo -> Id
320 setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
322 ---------------------------------
324 idStrictness :: Id -> StrictnessInfo
325 idStrictness id = strictnessInfo (idInfo id)
327 setIdStrictness :: Id -> StrictnessInfo -> Id
328 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
330 -- isBottomingId returns true if an application to n args would diverge
331 isBottomingId :: Id -> Bool
332 isBottomingId id = isBottomingStrictness (idStrictness id)
334 ---------------------------------
335 -- TYPE GENERALISATION
336 idTyGenInfo :: Id -> TyGenInfo
337 idTyGenInfo id = tyGenInfo (idInfo id)
339 setIdTyGenInfo :: Id -> TyGenInfo -> Id
340 setIdTyGenInfo id tygen_info = modifyIdInfo (`setTyGenInfo` tygen_info) id
342 ---------------------------------
344 idWorkerInfo :: Id -> WorkerInfo
345 idWorkerInfo id = workerInfo (idInfo id)
347 setIdWorkerInfo :: Id -> WorkerInfo -> Id
348 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
350 ---------------------------------
352 idUnfolding :: Id -> Unfolding
353 idUnfolding id = unfoldingInfo (idInfo id)
355 setIdUnfolding :: Id -> Unfolding -> Id
356 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
358 ---------------------------------
360 idDemandInfo :: Id -> Demand
361 idDemandInfo id = demandInfo (idInfo id)
363 setIdDemandInfo :: Id -> Demand -> Id
364 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
366 ---------------------------------
368 idSpecialisation :: Id -> CoreRules
369 idSpecialisation id = specInfo (idInfo id)
371 setIdSpecialisation :: Id -> CoreRules -> Id
372 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
374 ---------------------------------
376 idCafInfo :: Id -> CafInfo
377 idCafInfo id = cafInfo (idInfo id)
379 setIdCafInfo :: Id -> CafInfo -> Id
380 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
382 ---------------------------------
384 idCprInfo :: Id -> CprInfo
385 idCprInfo id = cprInfo (idInfo id)
387 setIdCprInfo :: Id -> CprInfo -> Id
388 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
390 ---------------------------------
392 idOccInfo :: Id -> OccInfo
393 idOccInfo id = occInfo (idInfo id)
395 setIdOccInfo :: Id -> OccInfo -> Id
396 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
400 ---------------------------------
402 The inline pragma tells us to be very keen to inline this Id, but it's still
403 OK not to if optimisation is switched off.
406 idInlinePragma :: Id -> InlinePragInfo
407 idInlinePragma id = inlinePragInfo (idInfo id)
409 setInlinePragma :: Id -> InlinePragInfo -> Id
410 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
412 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
413 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
417 ---------------------------------
420 idLBVarInfo :: Id -> LBVarInfo
421 idLBVarInfo id = lbvarInfo (idInfo id)
423 isOneShotLambda :: Id -> Bool
424 isOneShotLambda id = analysis || hack
425 where analysis = case idLBVarInfo id of
426 LBVarInfo u | u == usOnce -> True
428 hack = case splitTyConApp_maybe (idType id) of
429 Just (tycon,_) | tycon == statePrimTyCon -> True
432 -- The last clause is a gross hack. It claims that
433 -- every function over realWorldStatePrimTy is a one-shot
434 -- function. This is pretty true in practice, and makes a big
435 -- difference. For example, consider
436 -- a `thenST` \ r -> ...E...
437 -- The early full laziness pass, if it doesn't know that r is one-shot
438 -- will pull out E (let's say it doesn't mention r) to give
439 -- let lvl = E in a `thenST` \ r -> ...lvl...
440 -- When `thenST` gets inlined, we end up with
441 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
442 -- and we don't re-inline E.
444 -- It would be better to spot that r was one-shot to start with, but
445 -- I don't want to rely on that.
447 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
448 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
450 setOneShotLambda :: Id -> Id
451 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` LBVarInfo usOnce) id
453 clearOneShotLambda :: Id -> Id
454 clearOneShotLambda id
455 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
458 -- But watch out: this may change the type of something else
460 -- If we change the one-shot-ness of x, f's type changes
464 zapFragileIdInfo :: Id -> Id
465 zapFragileIdInfo id = maybeModifyIdInfo zapFragileInfo id
467 zapLamIdInfo :: Id -> Id
468 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id