2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section[Id]{@Ids@: Value and constructor identifiers}
11 -- Simple construction
12 mkGlobalId, mkLocalId, mkLocalIdWithInfo,
13 mkSysLocal, mkUserLocal, mkVanillaGlobal,
14 mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
15 mkWorkerId, mkExportedLocalId,
18 idName, idType, idUnique, idInfo,
19 isId, globalIdDetails, idPrimRep,
20 recordSelectorFieldLabel,
23 setIdName, setIdUnique, Id.setIdType, setIdExported, setIdNotExported,
24 setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
25 zapLamIdInfo, zapDemandIdInfo, zapFragileIdInfo,
28 isImplicitId, isDeadBinder, isDictId, isStrictId,
29 isExportedId, isLocalId, isGlobalId,
30 isRecordSelector, isNaughtyRecordSelector,
32 isPrimOpId, isPrimOpId_maybe,
33 isFCallId, isFCallId_maybe,
34 isDataConWorkId, isDataConWorkId_maybe, isDataConId_maybe, idDataCon,
35 isBottomingId, idIsFrom,
36 isTickBoxOp, isTickBoxOp_maybe,
39 -- Inline pragma stuff
40 idInlinePragma, setInlinePragma, modifyInlinePragma,
43 -- One shot lambda stuff
44 isOneShotBndr, isOneShotLambda, isStateHackType,
45 setOneShotLambda, clearOneShotLambda,
51 setIdNewStrictness, zapIdNewStrictness,
67 idNewDemandInfo, idNewDemandInfo_maybe,
68 idNewStrictness, idNewStrictness_maybe,
71 idSpecialisation, idCoreRules, idHasRules,
77 newStrictnessFromOld -- Temporary
82 #include "HsVersions.h"
87 import Var hiding (mkLocalId, mkGlobalId, mkExportedLocalId)
94 import qualified Demand
108 -- infixl so you can say (id `set` a `set` b)
109 infixl 1 `setIdUnfolding`,
111 `setIdNewDemandInfo`,
112 `setIdNewStrictness`,
114 `setIdSpecialisation`,
117 #ifdef OLD_STRICTNESS
126 %************************************************************************
128 \subsection{Simple Id construction}
130 %************************************************************************
132 Absolutely all Ids are made by mkId. It is just like Var.mkId,
133 but in addition it pins free-tyvar-info onto the Id's type,
134 where it can easily be found.
137 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
138 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
140 mkExportedLocalId :: Name -> Type -> Id
141 mkExportedLocalId name ty = Var.mkExportedLocalId name (addFreeTyVars ty) vanillaIdInfo
143 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
144 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
148 mkLocalId :: Name -> Type -> Id
149 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
151 -- SysLocal: for an Id being created by the compiler out of thin air...
152 mkSysLocal :: FastString -> Unique -> Type -> Id
153 mkSysLocal fs uniq ty = mkLocalId (mkSystemVarName uniq fs) ty
156 -- UserLocal: an Id with a name the user might recognize...
157 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
158 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
160 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
161 mkVanillaGlobal = mkGlobalId VanillaGlobal
164 Make some local @Ids@ for a template @CoreExpr@. These have bogus
165 @Uniques@, but that's OK because the templates are supposed to be
166 instantiated before use.
169 -- "Wild Id" typically used when you need a binder that you don't expect to use
170 mkWildId :: Type -> Id
171 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
173 mkWorkerId :: Unique -> Id -> Type -> Id
174 -- A worker gets a local name. CoreTidy will externalise it if necessary.
175 mkWorkerId uniq unwrkr ty
176 = mkLocalId wkr_name ty
178 wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
180 -- "Template locals" typically used in unfoldings
181 mkTemplateLocals :: [Type] -> [Id]
182 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
184 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
185 -- The Int gives the starting point for unique allocation
186 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
188 mkTemplateLocal :: Int -> Type -> Id
189 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
193 %************************************************************************
195 \subsection[Id-general-funs]{General @Id@-related functions}
197 %************************************************************************
200 setIdType :: Id -> Type -> Id
201 -- Add free tyvar info to the type
202 setIdType id ty = seqType ty `seq` Var.setIdType id (addFreeTyVars ty)
204 idPrimRep :: Id -> PrimRep
205 idPrimRep id = typePrimRep (idType id)
209 %************************************************************************
211 \subsection{Special Ids}
213 %************************************************************************
216 recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
217 recordSelectorFieldLabel id
218 = case globalIdDetails id of
219 RecordSelId { sel_tycon = tycon, sel_label = lbl } -> (tycon,lbl)
220 other -> panic "recordSelectorFieldLabel"
222 isRecordSelector id = case globalIdDetails id of
223 RecordSelId {} -> True
226 isNaughtyRecordSelector id = case globalIdDetails id of
227 RecordSelId { sel_naughty = n } -> n
230 isClassOpId_maybe id = case globalIdDetails id of
231 ClassOpId cls -> Just cls
234 isPrimOpId id = case globalIdDetails id of
238 isPrimOpId_maybe id = case globalIdDetails id of
239 PrimOpId op -> Just op
242 isFCallId id = case globalIdDetails id of
246 isFCallId_maybe id = case globalIdDetails id of
247 FCallId call -> Just call
250 isDataConWorkId id = case globalIdDetails id of
251 DataConWorkId _ -> True
254 isDataConWorkId_maybe id = case globalIdDetails id of
255 DataConWorkId con -> Just con
258 isDataConId_maybe :: Id -> Maybe DataCon
259 isDataConId_maybe id = case globalIdDetails id of
260 DataConWorkId con -> Just con
261 DataConWrapId con -> Just con
264 idDataCon :: Id -> DataCon
265 -- Get from either the worker or the wrapper to the DataCon
266 -- Currently used only in the desugarer
267 -- INVARIANT: idDataCon (dataConWrapId d) = d
268 -- (Remember, dataConWrapId can return either the wrapper or the worker.)
269 idDataCon id = case globalIdDetails id of
270 DataConWorkId con -> con
271 DataConWrapId con -> con
272 other -> pprPanic "idDataCon" (ppr id)
275 isDictId :: Id -> Bool
276 isDictId id = isDictTy (idType id)
278 -- hasNoBinding returns True of an Id which may not have a
279 -- binding, even though it is defined in this module.
280 -- Data constructor workers used to be things of this kind, but
281 -- they aren't any more. Instead, we inject a binding for
282 -- them at the CorePrep stage.
283 -- EXCEPT: unboxed tuples, which definitely have no binding
284 hasNoBinding id = case globalIdDetails id of
287 DataConWorkId dc -> isUnboxedTupleCon dc
290 isImplicitId :: Id -> Bool
291 -- isImplicitId tells whether an Id's info is implied by other
292 -- declarations, so we don't need to put its signature in an interface
293 -- file, even if it's mentioned in some other interface unfolding.
295 = case globalIdDetails id of
296 RecordSelId {} -> True
300 DataConWorkId _ -> True
301 DataConWrapId _ -> True
302 -- These are are implied by their type or class decl;
303 -- remember that all type and class decls appear in the interface file.
304 -- The dfun id is not an implicit Id; it must *not* be omitted, because
305 -- it carries version info for the instance decl
308 idIsFrom :: Module -> Id -> Bool
309 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
313 isDeadBinder :: Id -> Bool
314 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
315 | otherwise = False -- TyVars count as not dead
319 isTickBoxOp :: Id -> Bool
321 case globalIdDetails id of
322 TickBoxOpId tick -> True
325 isTickBoxOp_maybe :: Id -> Maybe TickBoxOp
326 isTickBoxOp_maybe id =
327 case globalIdDetails id of
328 TickBoxOpId tick -> Just tick
332 %************************************************************************
334 \subsection{IdInfo stuff}
336 %************************************************************************
339 ---------------------------------
341 idArity :: Id -> Arity
342 idArity id = arityInfo (idInfo id)
344 setIdArity :: Id -> Arity -> Id
345 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
347 #ifdef OLD_STRICTNESS
348 ---------------------------------
350 idStrictness :: Id -> StrictnessInfo
351 idStrictness id = strictnessInfo (idInfo id)
353 setIdStrictness :: Id -> StrictnessInfo -> Id
354 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
357 -- isBottomingId returns true if an application to n args would diverge
358 isBottomingId :: Id -> Bool
359 isBottomingId id = isBottomingSig (idNewStrictness id)
361 idNewStrictness_maybe :: Id -> Maybe StrictSig
362 idNewStrictness :: Id -> StrictSig
364 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
365 idNewStrictness id = idNewStrictness_maybe id `orElse` topSig
367 setIdNewStrictness :: Id -> StrictSig -> Id
368 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
370 zapIdNewStrictness :: Id -> Id
371 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
374 This predicate says whether the id has a strict demand placed on it or
375 has a type such that it can always be evaluated strictly (e.g., an
376 unlifted type, but see the comment for isStrictType). We need to
377 check separately whether <id> has a so-called "strict type" because if
378 the demand for <id> hasn't been computed yet but <id> has a strict
379 type, we still want (isStrictId <id>) to be True.
381 isStrictId :: Id -> Bool
383 = ASSERT2( isId id, text "isStrictId: not an id: " <+> ppr id )
384 (isStrictDmd (idNewDemandInfo id)) ||
385 (isStrictType (idType id))
387 ---------------------------------
389 idWorkerInfo :: Id -> WorkerInfo
390 idWorkerInfo id = workerInfo (idInfo id)
392 setIdWorkerInfo :: Id -> WorkerInfo -> Id
393 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
395 ---------------------------------
397 idUnfolding :: Id -> Unfolding
398 idUnfolding id = unfoldingInfo (idInfo id)
400 setIdUnfolding :: Id -> Unfolding -> Id
401 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
403 #ifdef OLD_STRICTNESS
404 ---------------------------------
406 idDemandInfo :: Id -> Demand.Demand
407 idDemandInfo id = demandInfo (idInfo id)
409 setIdDemandInfo :: Id -> Demand.Demand -> Id
410 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
413 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
414 idNewDemandInfo :: Id -> NewDemand.Demand
416 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
417 idNewDemandInfo id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
419 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
420 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
422 ---------------------------------
424 idSpecialisation :: Id -> SpecInfo
425 idSpecialisation id = specInfo (idInfo id)
427 idCoreRules :: Id -> [CoreRule]
428 idCoreRules id = specInfoRules (idSpecialisation id)
430 idHasRules :: Id -> Bool
431 idHasRules id = not (isEmptySpecInfo (idSpecialisation id))
433 setIdSpecialisation :: Id -> SpecInfo -> Id
434 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
436 ---------------------------------
438 idCafInfo :: Id -> CafInfo
439 #ifdef OLD_STRICTNESS
440 idCafInfo id = case cgInfo (idInfo id) of
441 NoCgInfo -> pprPanic "idCafInfo" (ppr id)
442 info -> cgCafInfo info
444 idCafInfo id = cafInfo (idInfo id)
447 setIdCafInfo :: Id -> CafInfo -> Id
448 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
450 ---------------------------------
452 #ifdef OLD_STRICTNESS
453 idCprInfo :: Id -> CprInfo
454 idCprInfo id = cprInfo (idInfo id)
456 setIdCprInfo :: Id -> CprInfo -> Id
457 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
460 ---------------------------------
462 idOccInfo :: Id -> OccInfo
463 idOccInfo id = occInfo (idInfo id)
465 setIdOccInfo :: Id -> OccInfo -> Id
466 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
470 ---------------------------------
472 The inline pragma tells us to be very keen to inline this Id, but it's still
473 OK not to if optimisation is switched off.
476 idInlinePragma :: Id -> InlinePragInfo
477 idInlinePragma id = inlinePragInfo (idInfo id)
479 setInlinePragma :: Id -> InlinePragInfo -> Id
480 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
482 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
483 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
487 ---------------------------------
490 idLBVarInfo :: Id -> LBVarInfo
491 idLBVarInfo id = lbvarInfo (idInfo id)
493 isOneShotBndr :: Id -> Bool
494 -- This one is the "business end", called externally.
495 -- Its main purpose is to encapsulate the Horrible State Hack
496 isOneShotBndr id = isOneShotLambda id || isStateHackType (idType id)
498 isStateHackType :: Type -> Bool
503 = case splitTyConApp_maybe ty of
504 Just (tycon,_) -> tycon == statePrimTyCon
506 -- This is a gross hack. It claims that
507 -- every function over realWorldStatePrimTy is a one-shot
508 -- function. This is pretty true in practice, and makes a big
509 -- difference. For example, consider
510 -- a `thenST` \ r -> ...E...
511 -- The early full laziness pass, if it doesn't know that r is one-shot
512 -- will pull out E (let's say it doesn't mention r) to give
513 -- let lvl = E in a `thenST` \ r -> ...lvl...
514 -- When `thenST` gets inlined, we end up with
515 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
516 -- and we don't re-inline E.
518 -- It would be better to spot that r was one-shot to start with, but
519 -- I don't want to rely on that.
521 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
522 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
525 -- The OneShotLambda functions simply fiddle with the IdInfo flag
526 isOneShotLambda :: Id -> Bool
527 isOneShotLambda id = case idLBVarInfo id of
528 IsOneShotLambda -> True
531 setOneShotLambda :: Id -> Id
532 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
534 clearOneShotLambda :: Id -> Id
535 clearOneShotLambda id
536 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
539 -- But watch out: this may change the type of something else
541 -- If we change the one-shot-ness of x, f's type changes
545 zapInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
546 zapInfo zapper id = maybeModifyIdInfo (zapper (idInfo id)) id
548 zapLamIdInfo :: Id -> Id
549 zapLamIdInfo = zapInfo zapLamInfo
551 zapDemandIdInfo = zapInfo zapDemandInfo
553 zapFragileIdInfo :: Id -> Id
554 zapFragileIdInfo = zapInfo zapFragileInfo