2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Id]{@Ids@: Value and constructor identifiers}
10 -- Simple construction
11 mkGlobalId, mkLocalId, mkSpecPragmaId, mkLocalIdWithInfo,
12 mkSysLocal, mkSysLocalUnencoded, mkUserLocal, mkVanillaGlobal,
13 mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
14 mkWorkerId, mkExportedLocalId,
17 idName, idType, idUnique, idInfo,
18 isId, globalIdDetails, idPrimRep,
19 recordSelectorFieldLabel,
22 setIdName, setIdUnique, Id.setIdType, setIdExported, setIdNotExported,
23 setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
24 zapLamIdInfo, zapDemandIdInfo,
27 isImplicitId, isDeadBinder,
28 isSpecPragmaId, isExportedId, isLocalId, isGlobalId,
30 isPrimOpId, isPrimOpId_maybe,
31 isFCallId, isFCallId_maybe,
32 isDataConWorkId, isDataConWorkId_maybe, idDataCon,
33 isBottomingId, idIsFrom,
36 -- Inline pragma stuff
37 idInlinePragma, setInlinePragma, modifyInlinePragma,
40 -- One shot lambda stuff
41 isOneShotBndr, isOneShotLambda, isStateHackType,
42 setOneShotLambda, clearOneShotLambda,
48 setIdNewStrictness, zapIdNewStrictness,
64 idNewDemandInfo, idNewDemandInfo_maybe,
65 idNewStrictness, idNewStrictness_maybe,
68 idSpecialisation, idCoreRules,
74 newStrictnessFromOld -- Temporary
79 #include "HsVersions.h"
82 import CoreSyn ( Unfolding, CoreRule )
83 import BasicTypes ( Arity )
84 import Var ( Id, DictId,
85 isId, isExportedId, isSpecPragmaId, isLocalId,
86 idName, idType, idUnique, idInfo, isGlobalId,
87 setIdName, setIdType, setIdUnique,
88 setIdExported, setIdNotExported,
89 setIdInfo, lazySetIdInfo, modifyIdInfo,
93 import qualified Var ( mkLocalId, mkGlobalId, mkSpecPragmaId, mkExportedLocalId )
94 import TyCon ( FieldLabel, TyCon )
95 import Type ( Type, typePrimRep, addFreeTyVars, seqType,
96 splitTyConApp_maybe, PrimRep )
97 import TysPrim ( statePrimTyCon )
100 #ifdef OLD_STRICTNESS
101 import qualified Demand ( Demand )
103 import DataCon ( DataCon, isUnboxedTupleCon )
104 import NewDemand ( Demand, StrictSig, topDmd, topSig, isBottomingSig )
105 import Name ( Name, OccName, nameIsLocalOrFrom,
106 mkSystemVarName, mkSystemVarNameEncoded, mkInternalName,
107 getOccName, getSrcLoc
109 import Module ( Module )
110 import OccName ( EncodedFS, mkWorkerOcc )
111 import Maybes ( orElse )
112 import SrcLoc ( SrcLoc )
114 import Unique ( Unique, mkBuiltinUnique )
115 import StaticFlags ( opt_NoStateHack )
117 -- infixl so you can say (id `set` a `set` b)
118 infixl 1 `setIdUnfolding`,
120 `setIdNewDemandInfo`,
121 `setIdNewStrictness`,
123 `setIdSpecialisation`,
126 #ifdef OLD_STRICTNESS
135 %************************************************************************
137 \subsection{Simple Id construction}
139 %************************************************************************
141 Absolutely all Ids are made by mkId. It is just like Var.mkId,
142 but in addition it pins free-tyvar-info onto the Id's type,
143 where it can easily be found.
146 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
147 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
149 mkSpecPragmaId :: Name -> Type -> Id
150 mkSpecPragmaId name ty = Var.mkSpecPragmaId name (addFreeTyVars ty) vanillaIdInfo
152 mkExportedLocalId :: Name -> Type -> Id
153 mkExportedLocalId name ty = Var.mkExportedLocalId name (addFreeTyVars ty) vanillaIdInfo
155 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
156 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
160 mkLocalId :: Name -> Type -> Id
161 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
163 -- SysLocal: for an Id being created by the compiler out of thin air...
164 -- UserLocal: an Id with a name the user might recognize...
165 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
166 mkSysLocal :: EncodedFS -> Unique -> Type -> Id
167 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
169 -- for SysLocal, we assume the base name is already encoded, to avoid
170 -- re-encoding the same string over and over again.
171 mkSysLocal fs uniq ty = mkLocalId (mkSystemVarNameEncoded uniq fs) ty
173 -- version to use when the faststring needs to be encoded
174 mkSysLocalUnencoded fs uniq ty = mkLocalId (mkSystemVarName uniq fs) ty
176 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
177 mkVanillaGlobal = mkGlobalId VanillaGlobal
180 Make some local @Ids@ for a template @CoreExpr@. These have bogus
181 @Uniques@, but that's OK because the templates are supposed to be
182 instantiated before use.
185 -- "Wild Id" typically used when you need a binder that you don't expect to use
186 mkWildId :: Type -> Id
187 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
189 mkWorkerId :: Unique -> Id -> Type -> Id
190 -- A worker gets a local name. CoreTidy will externalise it if necessary.
191 mkWorkerId uniq unwrkr ty
192 = mkLocalId wkr_name ty
194 wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
196 -- "Template locals" typically used in unfoldings
197 mkTemplateLocals :: [Type] -> [Id]
198 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
200 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
201 -- The Int gives the starting point for unique allocation
202 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
204 mkTemplateLocal :: Int -> Type -> Id
205 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
209 %************************************************************************
211 \subsection[Id-general-funs]{General @Id@-related functions}
213 %************************************************************************
216 setIdType :: Id -> Type -> Id
217 -- Add free tyvar info to the type
218 setIdType id ty = seqType ty `seq` Var.setIdType id (addFreeTyVars ty)
220 idPrimRep :: Id -> PrimRep
221 idPrimRep id = typePrimRep (idType id)
225 %************************************************************************
227 \subsection{Special Ids}
229 %************************************************************************
231 The @SpecPragmaId@ exists only to make Ids that are
232 on the *LHS* of bindings created by SPECIALISE pragmas;
234 The SpecPragmaId is never itself mentioned; it
235 exists solely so that the specialiser will find
236 the call to f, and make specialised version of it.
237 The SpecPragmaId binding is discarded by the specialiser
238 when it gathers up overloaded calls.
239 Meanwhile, it is not discarded as dead code.
243 recordSelectorFieldLabel :: Id -> (TyCon, FieldLabel)
244 recordSelectorFieldLabel id = case globalIdDetails id of
245 RecordSelId tycon lbl -> (tycon,lbl)
246 other -> panic "recordSelectorFieldLabel"
248 isRecordSelector id = case globalIdDetails id of
249 RecordSelId _ _ -> True
252 isPrimOpId id = case globalIdDetails id of
256 isPrimOpId_maybe id = case globalIdDetails id of
257 PrimOpId op -> Just op
260 isFCallId id = case globalIdDetails id of
264 isFCallId_maybe id = case globalIdDetails id of
265 FCallId call -> Just call
268 isDataConWorkId id = case globalIdDetails id of
269 DataConWorkId _ -> True
272 isDataConWorkId_maybe id = case globalIdDetails id of
273 DataConWorkId con -> Just con
276 idDataCon :: Id -> DataCon
277 -- Get from either the worker or the wrapper to the DataCon
278 -- Currently used only in the desugarer
279 -- INVARIANT: idDataCon (dataConWrapId d) = d
280 -- (Remember, dataConWrapId can return either the wrapper or the worker.)
281 idDataCon id = case globalIdDetails id of
282 DataConWorkId con -> con
283 DataConWrapId con -> con
284 other -> pprPanic "idDataCon" (ppr id)
287 -- hasNoBinding returns True of an Id which may not have a
288 -- binding, even though it is defined in this module.
289 -- Data constructor workers used to be things of this kind, but
290 -- they aren't any more. Instead, we inject a binding for
291 -- them at the CorePrep stage.
292 -- EXCEPT: unboxed tuples, which definitely have no binding
293 hasNoBinding id = case globalIdDetails id of
296 DataConWorkId dc -> isUnboxedTupleCon dc
299 isImplicitId :: Id -> Bool
300 -- isImplicitId tells whether an Id's info is implied by other
301 -- declarations, so we don't need to put its signature in an interface
302 -- file, even if it's mentioned in some other interface unfolding.
304 = case globalIdDetails id of
305 RecordSelId _ _ -> True
309 DataConWorkId _ -> True
310 DataConWrapId _ -> True
311 -- These are are implied by their type or class decl;
312 -- remember that all type and class decls appear in the interface file.
313 -- The dfun id is not an implicit Id; it must *not* be omitted, because
314 -- it carries version info for the instance decl
317 idIsFrom :: Module -> Id -> Bool
318 idIsFrom mod id = nameIsLocalOrFrom mod (idName id)
322 isDeadBinder :: Id -> Bool
323 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
324 | otherwise = False -- TyVars count as not dead
328 %************************************************************************
330 \subsection{IdInfo stuff}
332 %************************************************************************
335 ---------------------------------
337 idArity :: Id -> Arity
338 idArity id = arityInfo (idInfo id)
340 setIdArity :: Id -> Arity -> Id
341 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
343 #ifdef OLD_STRICTNESS
344 ---------------------------------
346 idStrictness :: Id -> StrictnessInfo
347 idStrictness id = strictnessInfo (idInfo id)
349 setIdStrictness :: Id -> StrictnessInfo -> Id
350 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
353 -- isBottomingId returns true if an application to n args would diverge
354 isBottomingId :: Id -> Bool
355 isBottomingId id = isBottomingSig (idNewStrictness id)
357 idNewStrictness_maybe :: Id -> Maybe StrictSig
358 idNewStrictness :: Id -> StrictSig
360 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
361 idNewStrictness id = idNewStrictness_maybe id `orElse` topSig
363 setIdNewStrictness :: Id -> StrictSig -> Id
364 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
366 zapIdNewStrictness :: Id -> Id
367 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
369 ---------------------------------
371 idWorkerInfo :: Id -> WorkerInfo
372 idWorkerInfo id = workerInfo (idInfo id)
374 setIdWorkerInfo :: Id -> WorkerInfo -> Id
375 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
377 ---------------------------------
379 idUnfolding :: Id -> Unfolding
380 idUnfolding id = unfoldingInfo (idInfo id)
382 setIdUnfolding :: Id -> Unfolding -> Id
383 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
385 #ifdef OLD_STRICTNESS
386 ---------------------------------
388 idDemandInfo :: Id -> Demand.Demand
389 idDemandInfo id = demandInfo (idInfo id)
391 setIdDemandInfo :: Id -> Demand.Demand -> Id
392 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
395 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
396 idNewDemandInfo :: Id -> NewDemand.Demand
398 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
399 idNewDemandInfo id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
401 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
402 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
404 ---------------------------------
406 idSpecialisation :: Id -> SpecInfo
407 idSpecialisation id = specInfo (idInfo id)
409 idCoreRules :: Id -> [CoreRule]
410 idCoreRules id = specInfoRules (idSpecialisation id)
412 setIdSpecialisation :: Id -> SpecInfo -> Id
413 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
415 ---------------------------------
417 idCafInfo :: Id -> CafInfo
418 #ifdef OLD_STRICTNESS
419 idCafInfo id = case cgInfo (idInfo id) of
420 NoCgInfo -> pprPanic "idCafInfo" (ppr id)
421 info -> cgCafInfo info
423 idCafInfo id = cafInfo (idInfo id)
426 setIdCafInfo :: Id -> CafInfo -> Id
427 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
429 ---------------------------------
431 #ifdef OLD_STRICTNESS
432 idCprInfo :: Id -> CprInfo
433 idCprInfo id = cprInfo (idInfo id)
435 setIdCprInfo :: Id -> CprInfo -> Id
436 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
439 ---------------------------------
441 idOccInfo :: Id -> OccInfo
442 idOccInfo id = occInfo (idInfo id)
444 setIdOccInfo :: Id -> OccInfo -> Id
445 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
449 ---------------------------------
451 The inline pragma tells us to be very keen to inline this Id, but it's still
452 OK not to if optimisation is switched off.
455 idInlinePragma :: Id -> InlinePragInfo
456 idInlinePragma id = inlinePragInfo (idInfo id)
458 setInlinePragma :: Id -> InlinePragInfo -> Id
459 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
461 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
462 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
466 ---------------------------------
469 idLBVarInfo :: Id -> LBVarInfo
470 idLBVarInfo id = lbvarInfo (idInfo id)
472 isOneShotBndr :: Id -> Bool
473 -- This one is the "business end", called externally.
474 -- Its main purpose is to encapsulate the Horrible State Hack
475 isOneShotBndr id = isOneShotLambda id || (isStateHackType (idType id))
477 isStateHackType :: Type -> Bool
482 = case splitTyConApp_maybe ty of
483 Just (tycon,_) -> tycon == statePrimTyCon
485 -- This is a gross hack. It claims that
486 -- every function over realWorldStatePrimTy is a one-shot
487 -- function. This is pretty true in practice, and makes a big
488 -- difference. For example, consider
489 -- a `thenST` \ r -> ...E...
490 -- The early full laziness pass, if it doesn't know that r is one-shot
491 -- will pull out E (let's say it doesn't mention r) to give
492 -- let lvl = E in a `thenST` \ r -> ...lvl...
493 -- When `thenST` gets inlined, we end up with
494 -- let lvl = E in \s -> case a s of (r, s') -> ...lvl...
495 -- and we don't re-inline E.
497 -- It would be better to spot that r was one-shot to start with, but
498 -- I don't want to rely on that.
500 -- Another good example is in fill_in in PrelPack.lhs. We should be able to
501 -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
504 -- The OneShotLambda functions simply fiddle with the IdInfo flag
505 isOneShotLambda :: Id -> Bool
506 isOneShotLambda id = case idLBVarInfo id of
507 IsOneShotLambda -> True
510 setOneShotLambda :: Id -> Id
511 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
513 clearOneShotLambda :: Id -> Id
514 clearOneShotLambda id
515 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
518 -- But watch out: this may change the type of something else
520 -- If we change the one-shot-ness of x, f's type changes
524 zapLamIdInfo :: Id -> Id
525 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
527 zapDemandIdInfo id = maybeModifyIdInfo zapDemandInfo id