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,
17 idName, idType, idUnique, idInfo,
18 idPrimRep, isId, globalIdDetails,
19 recordSelectorFieldLabel,
22 setIdName, setIdUnique, setIdType, setIdLocalExported, setGlobalIdDetails,
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,
33 isDataConWrapId, isDataConWrapId_maybe,
37 -- Inline pragma stuff
38 idInlinePragma, setInlinePragma, modifyInlinePragma,
41 -- One shot lambda stuff
42 isOneShotLambda, 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, CoreRules, IdCoreRule, rulesRules )
83 import BasicTypes ( Arity )
84 import Var ( Id, DictId,
85 isId, isExportedId, isSpecPragmaId, isLocalId,
86 idName, idType, idUnique, idInfo, isGlobalId,
87 setIdName, setVarType, setIdUnique, setIdLocalExported,
88 setIdInfo, lazySetIdInfo, modifyIdInfo,
90 globalIdDetails, setGlobalIdDetails
92 import qualified Var ( mkLocalId, mkGlobalId, mkSpecPragmaId )
93 import Type ( Type, typePrimRep, addFreeTyVars,
94 seqType, splitTyConApp_maybe )
99 import qualified Demand ( Demand )
101 import DataCon ( isUnboxedTupleCon )
102 import NewDemand ( Demand, StrictSig, topDmd, topSig, isBottomingSig )
103 import Name ( Name, OccName,
104 mkSystemName, mkSystemNameEncoded, mkInternalName,
105 getOccName, getSrcLoc
107 import OccName ( EncodedFS, mkWorkerOcc )
108 import PrimRep ( PrimRep )
109 import FieldLabel ( FieldLabel )
110 import Maybes ( orElse )
111 import SrcLoc ( SrcLoc )
113 import Unique ( Unique, mkBuiltinUnique )
115 -- infixl so you can say (id `set` a `set` b)
116 infixl 1 `setIdUnfolding`,
118 `setIdNewDemandInfo`,
119 `setIdNewStrictness`,
121 `setIdSpecialisation`,
124 #ifdef OLD_STRICTNESS
133 %************************************************************************
135 \subsection{Simple Id construction}
137 %************************************************************************
139 Absolutely all Ids are made by mkId. It is just like Var.mkId,
140 but in addition it pins free-tyvar-info onto the Id's type,
141 where it can easily be found.
144 mkLocalIdWithInfo :: Name -> Type -> IdInfo -> Id
145 mkLocalIdWithInfo name ty info = Var.mkLocalId name (addFreeTyVars ty) info
147 mkSpecPragmaId :: Name -> Type -> Id
148 mkSpecPragmaId name ty = Var.mkSpecPragmaId name (addFreeTyVars ty) vanillaIdInfo
150 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
151 mkGlobalId details name ty info = Var.mkGlobalId details name (addFreeTyVars ty) info
155 mkLocalId :: Name -> Type -> Id
156 mkLocalId name ty = mkLocalIdWithInfo name ty vanillaIdInfo
158 -- SysLocal: for an Id being created by the compiler out of thin air...
159 -- UserLocal: an Id with a name the user might recognize...
160 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
161 mkSysLocal :: EncodedFS -> Unique -> Type -> Id
162 mkVanillaGlobal :: Name -> Type -> IdInfo -> Id
164 -- for SysLocal, we assume the base name is already encoded, to avoid
165 -- re-encoding the same string over and over again.
166 mkSysLocal fs uniq ty = mkLocalId (mkSystemNameEncoded uniq fs) ty
168 -- version to use when the faststring needs to be encoded
169 mkSysLocalUnencoded fs uniq ty = mkLocalId (mkSystemName uniq fs) ty
171 mkUserLocal occ uniq ty loc = mkLocalId (mkInternalName uniq occ loc) ty
172 mkVanillaGlobal = mkGlobalId VanillaGlobal
175 Make some local @Ids@ for a template @CoreExpr@. These have bogus
176 @Uniques@, but that's OK because the templates are supposed to be
177 instantiated before use.
180 -- "Wild Id" typically used when you need a binder that you don't expect to use
181 mkWildId :: Type -> Id
182 mkWildId ty = mkSysLocal FSLIT("wild") (mkBuiltinUnique 1) ty
184 mkWorkerId :: Unique -> Id -> Type -> Id
185 -- A worker gets a local name. CoreTidy will externalise it if necessary.
186 mkWorkerId uniq unwrkr ty
187 = mkLocalId wkr_name ty
189 wkr_name = mkInternalName uniq (mkWorkerOcc (getOccName unwrkr)) (getSrcLoc unwrkr)
191 -- "Template locals" typically used in unfoldings
192 mkTemplateLocals :: [Type] -> [Id]
193 mkTemplateLocals tys = zipWith mkTemplateLocal [1..] tys
195 mkTemplateLocalsNum :: Int -> [Type] -> [Id]
196 -- The Int gives the starting point for unique allocation
197 mkTemplateLocalsNum n tys = zipWith mkTemplateLocal [n..] tys
199 mkTemplateLocal :: Int -> Type -> Id
200 mkTemplateLocal i ty = mkSysLocal FSLIT("tpl") (mkBuiltinUnique i) ty
204 %************************************************************************
206 \subsection[Id-general-funs]{General @Id@-related functions}
208 %************************************************************************
211 setIdType :: Id -> Type -> Id
212 -- Add free tyvar info to the type
213 setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
215 idPrimRep :: Id -> PrimRep
216 idPrimRep id = typePrimRep (idType id)
220 %************************************************************************
222 \subsection{Special Ids}
224 %************************************************************************
226 The @SpecPragmaId@ exists only to make Ids that are
227 on the *LHS* of bindings created by SPECIALISE pragmas;
229 The SpecPragmaId is never itself mentioned; it
230 exists solely so that the specialiser will find
231 the call to f, and make specialised version of it.
232 The SpecPragmaId binding is discarded by the specialiser
233 when it gathers up overloaded calls.
234 Meanwhile, it is not discarded as dead code.
238 recordSelectorFieldLabel :: Id -> FieldLabel
239 recordSelectorFieldLabel id = case globalIdDetails id of
240 RecordSelId lbl -> lbl
242 isRecordSelector id = case globalIdDetails id of
243 RecordSelId lbl -> True
246 isPrimOpId id = case globalIdDetails id of
250 isPrimOpId_maybe id = case globalIdDetails id of
251 PrimOpId op -> Just op
254 isFCallId id = case globalIdDetails id of
258 isFCallId_maybe id = case globalIdDetails id of
259 FCallId call -> Just call
262 isDataConWorkId id = case globalIdDetails id of
263 DataConWorkId _ -> True
266 isDataConWorkId_maybe id = case globalIdDetails id of
267 DataConWorkId con -> Just con
270 isDataConWrapId_maybe id = case globalIdDetails id of
271 DataConWrapId con -> Just con
274 isDataConWrapId id = case globalIdDetails id of
275 DataConWrapId con -> True
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 GenericOpId _ -> True
301 DataConWorkId _ -> True
302 DataConWrapId _ -> True
303 -- These are are implied by their type or class decl;
304 -- remember that all type and class decls appear in the interface file.
305 -- The dfun id is not an implicit Id; it must *not* be omitted, because
306 -- it carries version info for the instance decl
311 isDeadBinder :: Id -> Bool
312 isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
313 | otherwise = False -- TyVars count as not dead
317 %************************************************************************
319 \subsection{IdInfo stuff}
321 %************************************************************************
324 ---------------------------------
326 idArity :: Id -> Arity
327 idArity id = arityInfo (idInfo id)
329 setIdArity :: Id -> Arity -> Id
330 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
332 #ifdef OLD_STRICTNESS
333 ---------------------------------
335 idStrictness :: Id -> StrictnessInfo
336 idStrictness id = strictnessInfo (idInfo id)
338 setIdStrictness :: Id -> StrictnessInfo -> Id
339 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
342 -- isBottomingId returns true if an application to n args would diverge
343 isBottomingId :: Id -> Bool
344 isBottomingId id = isBottomingSig (idNewStrictness id)
346 idNewStrictness_maybe :: Id -> Maybe StrictSig
347 idNewStrictness :: Id -> StrictSig
349 idNewStrictness_maybe id = newStrictnessInfo (idInfo id)
350 idNewStrictness id = idNewStrictness_maybe id `orElse` topSig
352 setIdNewStrictness :: Id -> StrictSig -> Id
353 setIdNewStrictness id sig = modifyIdInfo (`setNewStrictnessInfo` Just sig) id
355 zapIdNewStrictness :: Id -> Id
356 zapIdNewStrictness id = modifyIdInfo (`setNewStrictnessInfo` Nothing) id
358 ---------------------------------
360 idWorkerInfo :: Id -> WorkerInfo
361 idWorkerInfo id = workerInfo (idInfo id)
363 setIdWorkerInfo :: Id -> WorkerInfo -> Id
364 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
366 ---------------------------------
368 idUnfolding :: Id -> Unfolding
369 idUnfolding id = unfoldingInfo (idInfo id)
371 setIdUnfolding :: Id -> Unfolding -> Id
372 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
374 #ifdef OLD_STRICTNESS
375 ---------------------------------
377 idDemandInfo :: Id -> Demand.Demand
378 idDemandInfo id = demandInfo (idInfo id)
380 setIdDemandInfo :: Id -> Demand.Demand -> Id
381 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
384 idNewDemandInfo_maybe :: Id -> Maybe NewDemand.Demand
385 idNewDemandInfo :: Id -> NewDemand.Demand
387 idNewDemandInfo_maybe id = newDemandInfo (idInfo id)
388 idNewDemandInfo id = newDemandInfo (idInfo id) `orElse` NewDemand.topDmd
390 setIdNewDemandInfo :: Id -> NewDemand.Demand -> Id
391 setIdNewDemandInfo id dmd = modifyIdInfo (`setNewDemandInfo` Just dmd) id
393 ---------------------------------
395 idSpecialisation :: Id -> CoreRules
396 idSpecialisation id = specInfo (idInfo id)
398 idCoreRules :: Id -> [IdCoreRule]
399 idCoreRules id = [(id,rule) | rule <- rulesRules (idSpecialisation id)]
401 setIdSpecialisation :: Id -> CoreRules -> Id
402 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
404 ---------------------------------
406 idCafInfo :: Id -> CafInfo
407 #ifdef OLD_STRICTNESS
408 idCafInfo id = case cgInfo (idInfo id) of
409 NoCgInfo -> pprPanic "idCafInfo" (ppr id)
410 info -> cgCafInfo info
412 idCafInfo id = cafInfo (idInfo id)
415 setIdCafInfo :: Id -> CafInfo -> Id
416 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
418 ---------------------------------
420 #ifdef OLD_STRICTNESS
421 idCprInfo :: Id -> CprInfo
422 idCprInfo id = cprInfo (idInfo id)
424 setIdCprInfo :: Id -> CprInfo -> Id
425 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
428 ---------------------------------
430 idOccInfo :: Id -> OccInfo
431 idOccInfo id = occInfo (idInfo id)
433 setIdOccInfo :: Id -> OccInfo -> Id
434 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
438 ---------------------------------
440 The inline pragma tells us to be very keen to inline this Id, but it's still
441 OK not to if optimisation is switched off.
444 idInlinePragma :: Id -> InlinePragInfo
445 idInlinePragma id = inlinePragInfo (idInfo id)
447 setInlinePragma :: Id -> InlinePragInfo -> Id
448 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
450 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
451 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
455 ---------------------------------
458 idLBVarInfo :: Id -> LBVarInfo
459 idLBVarInfo id = lbvarInfo (idInfo id)
461 isOneShotLambda :: Id -> Bool
462 isOneShotLambda id = case idLBVarInfo id of
463 IsOneShotLambda -> True
466 setOneShotLambda :: Id -> Id
467 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
469 clearOneShotLambda :: Id -> Id
470 clearOneShotLambda id
471 | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
474 -- But watch out: this may change the type of something else
476 -- If we change the one-shot-ness of x, f's type changes
480 zapLamIdInfo :: Id -> Id
481 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
483 zapDemandIdInfo id = maybeModifyIdInfo zapDemandInfo id