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,
28 isSpecPragmaId, isRecordSelector,
29 isPrimOpId, isPrimOpId_maybe,
30 isDataConId, isDataConId_maybe, isDataConWrapId,
31 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 -- Don't drop a binding for an exported Id,
248 -- if it otherwise looks dead.
249 -- Perhaps a better name would be isDiscardableId
250 isExportedId :: Id -> Bool
251 isExportedId id = case idFlavour id of
255 isLocalId :: Id -> Bool
256 -- True of Ids that are locally defined, but are not constants
257 -- like data constructors, record selectors, and the like.
258 -- See comments with CoreFVs.isLocalVar
261 | not (isId id) = pprTrace "isLocalid" (ppr id) False
264 = case idFlavour id of
272 omitIfaceSigForId tells whether an Id's info is implied by other declarations,
273 so we don't need to put its signature in an interface file, even if it's mentioned
274 in some other interface unfolding.
277 omitIfaceSigForId :: Id -> Bool
279 = ASSERT2( not (omit && nameIsLocallyDefined (idName id)
280 && idTyGenInfo id /= TyGenNever),
282 -- mustn't omit type signature for a name whose type might change!
285 omit = omitIfaceSigForId' id
287 omitIfaceSigForId' id
288 = case idFlavour id of
289 RecordSelId _ -> True -- Includes dictionary selectors
292 DataConWrapId _ -> True
293 -- These are are implied by their type or class decl;
294 -- remember that all type and class decls appear in the interface file.
295 -- The dfun id must *not* be omitted, because it carries version info for
298 other -> False -- Don't omit!
302 isDeadBinder :: Id -> Bool
303 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
304 | otherwise = False -- TyVars count as not dead
306 isIP id = isIPOcc (getOccName id)
310 %************************************************************************
312 \subsection{IdInfo stuff}
314 %************************************************************************
317 ---------------------------------
319 idArityInfo :: Id -> ArityInfo
320 idArityInfo id = arityInfo (idInfo id)
322 idArity :: Id -> Arity
323 idArity id = arityLowerBound (idArityInfo id)
325 setIdArityInfo :: Id -> ArityInfo -> Id
326 setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
328 ---------------------------------
330 idStrictness :: Id -> StrictnessInfo
331 idStrictness id = strictnessInfo (idInfo id)
333 setIdStrictness :: Id -> StrictnessInfo -> Id
334 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
336 -- isBottomingId returns true if an application to n args would diverge
337 isBottomingId :: Id -> Bool
338 isBottomingId id = isBottomingStrictness (idStrictness id)
340 ---------------------------------
341 -- TYPE GENERALISATION
342 idTyGenInfo :: Id -> TyGenInfo
343 idTyGenInfo id = tyGenInfo (idInfo id)
345 setIdTyGenInfo :: Id -> TyGenInfo -> Id
346 setIdTyGenInfo id tygen_info = modifyIdInfo (`setTyGenInfo` tygen_info) id
348 ---------------------------------
350 idWorkerInfo :: Id -> WorkerInfo
351 idWorkerInfo id = workerInfo (idInfo id)
353 setIdWorkerInfo :: Id -> WorkerInfo -> Id
354 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
356 ---------------------------------
358 idUnfolding :: Id -> Unfolding
359 idUnfolding id = unfoldingInfo (idInfo id)
361 setIdUnfolding :: Id -> Unfolding -> Id
362 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
364 ---------------------------------
366 idDemandInfo :: Id -> Demand
367 idDemandInfo id = demandInfo (idInfo id)
369 setIdDemandInfo :: Id -> Demand -> Id
370 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
372 ---------------------------------
374 idSpecialisation :: Id -> CoreRules
375 idSpecialisation id = specInfo (idInfo id)
377 setIdSpecialisation :: Id -> CoreRules -> Id
378 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
380 ---------------------------------
382 idCafInfo :: Id -> CafInfo
383 idCafInfo id = cafInfo (idInfo id)
385 setIdCafInfo :: Id -> CafInfo -> Id
386 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
388 ---------------------------------
390 idCprInfo :: Id -> CprInfo
391 idCprInfo id = cprInfo (idInfo id)
393 setIdCprInfo :: Id -> CprInfo -> Id
394 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
396 ---------------------------------
398 idOccInfo :: Id -> OccInfo
399 idOccInfo id = occInfo (idInfo id)
401 setIdOccInfo :: Id -> OccInfo -> Id
402 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
406 ---------------------------------
408 The inline pragma tells us to be very keen to inline this Id, but it's still
409 OK not to if optimisation is switched off.
412 idInlinePragma :: Id -> InlinePragInfo
413 idInlinePragma id = inlinePragInfo (idInfo id)
415 setInlinePragma :: Id -> InlinePragInfo -> Id
416 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
418 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
419 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
423 ---------------------------------
426 idLBVarInfo :: Id -> LBVarInfo
427 idLBVarInfo id = lbvarInfo (idInfo id)
429 isOneShotLambda :: Id -> Bool
430 isOneShotLambda id = analysis || hack
431 where analysis = case idLBVarInfo id of
432 LBVarInfo u | u == usOnce -> True
434 hack = case splitTyConApp_maybe (idType id) of
435 Just (tycon,_) | tycon == statePrimTyCon -> True
438 -- The last clause is a gross hack. It claims that
439 -- every function over realWorldStatePrimTy is a one-shot
440 -- function. This is pretty true in practice, and makes a big
441 -- difference. For example, consider
442 -- a `thenST` \ r -> ...E...
443 -- The early full laziness pass, if it doesn't know that r is one-shot
444 -- will pull out E (let's say it doesn't mention r) to give
445 -- let lvl = E in a `thenST` \ r -> ...lvl...
446 -- When `thenST` gets inlined, we end up with
447 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
448 -- and we don't re-inline E.
450 -- It would be better to spot that r was one-shot to start with, but
451 -- I don't want to rely on that.
453 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
454 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
456 setOneShotLambda :: Id -> Id
457 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` LBVarInfo usOnce) id
459 clearOneShotLambda :: Id -> Id
460 clearOneShotLambda id
461 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
464 -- But watch out: this may change the type of something else
466 -- If we change the one-shot-ness of x, f's type changes
470 zapFragileIdInfo :: Id -> Id
471 zapFragileIdInfo id = maybeModifyIdInfo zapFragileInfo id
473 zapLamIdInfo :: Id -> Id
474 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id