Id.lhs 12.9 KB
Newer Older
1 2
%
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 4 5 6
%
\section[Id]{@Ids@: Value and constructor identifiers}

\begin{code}
7
module Id (
8
	Id, DictId,
9

10
	-- Simple construction
11
	mkId, mkVanillaId, mkSysLocal, mkUserLocal,
12
	mkTemplateLocals, mkTemplateLocalsNum, mkWildId, mkTemplateLocal,
13 14

	-- Taking an Id apart
15
	idName, idType, idUnique, idInfo,
16
	idPrimRep, isId,
17
	recordSelectorFieldLabel,
18

19
	-- Modifying an Id
20
	setIdName, setIdUnique, setIdType, setIdNoDiscard, 
21
	setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
22
	zapFragileIdInfo, zapLamIdInfo,
23 24

	-- Predicates
25
	omitIfaceSigForId, isDeadBinder,
26
	exportWithOrigOccName,
27
	externallyVisibleId,
28 29
	idFreeTyVars,
	isIP,
30
	isSpecPragmaId,	isRecordSelector,
31
	isPrimOpId, isPrimOpId_maybe, 
32 33
	isDataConId, isDataConId_maybe, isDataConWrapId, 
		isDataConWrapId_maybe,
34
	isBottomingId,
35
	isExportedId, isUserExportedId,
36 37 38 39 40
	hasNoBinding,

	-- Inline pragma stuff
	idInlinePragma, setInlinePragma, modifyInlinePragma, 

41

42
	-- One shot lambda stuff
43
	isOneShotLambda, setOneShotLambda, clearOneShotLambda,
44

45 46
	-- IdInfo stuff
	setIdUnfolding,
47
	setIdArityInfo,
48 49
	setIdDemandInfo,
	setIdStrictness,
50
	setIdWorkerInfo,
51 52
	setIdSpecialisation,
	setIdCafInfo,
53
	setIdCprInfo,
54
	setIdOccInfo,
55

56 57 58 59 60 61 62 63 64 65
	idArity, idArityInfo, 
	idFlavour,
	idDemandInfo,
	idStrictness,
	idWorkerInfo,
	idUnfolding,
	idSpecialisation,
	idCafInfo,
	idCprInfo,
	idLBVarInfo,
66
	idOccInfo,
67

68
    ) where
69

70
#include "HsVersions.h"
sof's avatar
sof committed
71 72


73
import CoreSyn		( Unfolding, CoreRules )
74
import BasicTypes	( Arity )
75 76 77 78
import Var		( Id, DictId,
			  isId, mkIdVar,
			  idName, idType, idUnique, idInfo,
			  setIdName, setVarType, setIdUnique, 
79 80
			  setIdInfo, lazySetIdInfo, modifyIdInfo, 
			  maybeModifyIdInfo,
81 82 83
			  externallyVisibleId
			)
import VarSet
84
import Type		( Type, tyVarsOfType, typePrimRep, addFreeTyVars, 
85
			  seqType, splitTyConApp_maybe )
86 87 88

import IdInfo 

89
import Demand		( Demand )
sof's avatar
sof committed
90
import Name	 	( Name, OccName,
91
			  mkSysLocalName, mkLocalName,
92
			  isUserExportedName, getOccName, isIPOcc
sof's avatar
sof committed
93
			) 
94
import OccName		( UserFS )
95
import PrimRep		( PrimRep )
96
import TysPrim		( statePrimTyCon )
97
import FieldLabel	( FieldLabel )
98
import SrcLoc		( SrcLoc )
99 100
import Unique		( Unique, mkBuiltinUnique, getBuiltinUniques, 
			  getNumBuiltinUniques )
101

102
infixl 	1 `setIdUnfolding`,
103
	  `setIdArityInfo`,
104 105
	  `setIdDemandInfo`,
	  `setIdStrictness`,
106
	  `setIdWorkerInfo`,
107
	  `setIdSpecialisation`,
108
	  `setInlinePragma`,
109 110
	  `idCafInfo`,
	  `idCprInfo`
111

112
	-- infixl so you can say (id `set` a `set` b)
113 114 115
\end{code}


116

117 118
%************************************************************************
%*									*
119
\subsection{Simple Id construction}
120 121 122
%*									*
%************************************************************************

123 124 125 126
Absolutely all Ids are made by mkId.  It 
	a) Pins free-tyvar-info onto the Id's type, 
	   where it can easily be found.
	b) Ensures that exported Ids are 
127

128 129 130 131 132 133 134
\begin{code}
mkId :: Name -> Type -> IdInfo -> Id
mkId name ty info = mkIdVar name (addFreeTyVars ty) info'
		  where
		    info' | isUserExportedName name = setNoDiscardInfo info
			  | otherwise		    = info
\end{code}
135

136 137 138
\begin{code}
mkVanillaId :: Name -> Type -> Id
mkVanillaId name ty = mkId name ty vanillaIdInfo
139 140 141

-- SysLocal: for an Id being created by the compiler out of thin air...
-- UserLocal: an Id with a name the user might recognize...
142 143
mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
mkSysLocal  :: UserFS  -> Unique -> Type -> Id
144

145 146
mkSysLocal  fs uniq ty      = mkVanillaId (mkSysLocalName uniq fs)      ty
mkUserLocal occ uniq ty loc = mkVanillaId (mkLocalName    uniq occ loc) ty
147
\end{code}
148 149 150 151 152 153

Make some local @Ids@ for a template @CoreExpr@.  These have bogus
@Uniques@, but that's OK because the templates are supposed to be
instantiated before use.

\begin{code}
154 155
-- "Wild Id" typically used when you need a binder that you don't expect to use
mkWildId :: Type -> Id
156
mkWildId ty = mkSysLocal SLIT("wild") (mkBuiltinUnique 1) ty
157 158

-- "Template locals" typically used in unfoldings
159
mkTemplateLocals :: [Type] -> [Id]
160
mkTemplateLocals tys = zipWith (mkSysLocal SLIT("tpl"))
161 162
			       (getBuiltinUniques (length tys))
			       tys
163

164 165 166 167 168
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
mkTemplateLocalsNum n tys = zipWith (mkSysLocal SLIT("tpl"))
			       (getNumBuiltinUniques n (length tys))
			       tys

169 170
mkTemplateLocal :: Int -> Type -> Id
mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
171 172 173
\end{code}


174 175 176 177 178 179 180
%************************************************************************
%*									*
\subsection[Id-general-funs]{General @Id@-related functions}
%*									*
%************************************************************************

\begin{code}
181
idFreeTyVars :: Id -> TyVarSet
182
idFreeTyVars id = tyVarsOfType (idType id)
183

184
setIdType :: Id -> Type -> Id
185
	-- Add free tyvar info to the type
186
setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
sof's avatar
sof committed
187

188 189
idPrimRep :: Id -> PrimRep
idPrimRep id = typePrimRep (idType id)
190 191 192 193 194
\end{code}


%************************************************************************
%*									*
195
\subsection{Special Ids}
196 197 198
%*									*
%************************************************************************

sof's avatar
sof committed
199
\begin{code}
200 201 202 203 204 205 206
idFlavour :: Id -> IdFlavour
idFlavour id = flavourInfo (idInfo id)

setIdNoDiscard :: Id -> Id
setIdNoDiscard id	-- Make an Id into a NoDiscardId, unless it is already
  = modifyIdInfo setNoDiscardInfo id

207
recordSelectorFieldLabel :: Id -> FieldLabel
208
recordSelectorFieldLabel id = case idFlavour id of
209
				RecordSelId lbl -> lbl
sof's avatar
sof committed
210

211
isRecordSelector id = case idFlavour id of
212 213
			RecordSelId lbl -> True
			other	  	-> False
sof's avatar
sof committed
214

215 216 217 218 219 220 221 222 223 224 225
isPrimOpId id = case idFlavour id of
		    PrimOpId op -> True
		    other	-> False

isPrimOpId_maybe id = case idFlavour id of
			    PrimOpId op -> Just op
			    other	-> Nothing

isDataConId id = case idFlavour id of
			DataConId _ -> True
			other	    -> False
sof's avatar
sof committed
226

227
isDataConId_maybe id = case idFlavour id of
228 229
			  DataConId con -> Just con
			  other	        -> Nothing
sof's avatar
sof committed
230

231 232 233
isDataConWrapId_maybe id = case idFlavour id of
				  DataConWrapId con -> Just con
				  other	            -> Nothing
234

235 236 237
isDataConWrapId id = case idFlavour id of
			DataConWrapId con -> True
			other	          -> False
238

239 240 241 242
isSpecPragmaId id = case idFlavour id of
			SpecPragmaId -> True
			other	     -> False

243
hasNoBinding id = case idFlavour id of
244 245 246
			DataConId _ -> True
			PrimOpId _  -> True
			other	    -> False
247
	-- hasNoBinding returns True of an Id which may not have a
248 249 250
	-- binding, even though it is defined in this module.  Notably,
	-- the constructors of a dictionary are in this situation.

251 252 253
-- Don't drop a binding for an exported Id,
-- if it otherwise looks dead.  
isExportedId :: Id -> Bool
254 255 256
isExportedId id = isUserExportedId id	-- Try this
{-
  case idFlavour id of
257 258
			VanillaId -> False
			other	  -> True	-- All the others are no-discard
259
-}
260 261 262 263 264

-- Say if an Id was exported by the user
-- Implies isExportedId (see mkId above)
isUserExportedId :: Id -> Bool
isUserExportedId id = isUserExportedName (idName id)
265 266
\end{code}

267

268 269 270 271 272 273 274 275 276
omitIfaceSigForId tells whether an Id's info is implied by other declarations,
so we don't need to put its signature in an interface file, even if it's mentioned
in some other interface unfolding.

\begin{code}
omitIfaceSigForId :: Id -> Bool
omitIfaceSigForId id
  | otherwise
  = case idFlavour id of
277 278 279 280 281
	RecordSelId _   -> True	-- Includes dictionary selectors
        PrimOpId _      -> True
        DataConId _     -> True
	DataConWrapId _ -> True
		-- These are are implied by their type or class decl;
282 283 284 285 286
		-- remember that all type and class decls appear in the interface file.
		-- The dfun id must *not* be omitted, because it carries version info for
		-- the instance decl

	other	       -> False	-- Don't omit!
287 288 289 290 291 292

-- Certain names must be exported with their original occ names, because
-- these names are bound by either a class declaration or a data declaration
-- or an explicit user export.
exportWithOrigOccName :: Id -> Bool
exportWithOrigOccName id = omitIfaceSigForId id || isUserExportedId id
293 294 295 296
\end{code}

\begin{code}
isDeadBinder :: Id -> Bool
297
isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
298
		  | otherwise = False	-- TyVars count as not dead
299 300

isIP id = isIPOcc (getOccName id)
301 302 303
\end{code}


304 305
%************************************************************************
%*									*
306
\subsection{IdInfo stuff}
307 308 309
%*									*
%************************************************************************

310
\begin{code}
311 312
	---------------------------------
	-- ARITY
313 314 315 316 317
idArityInfo :: Id -> ArityInfo
idArityInfo id = arityInfo (idInfo id)

idArity :: Id -> Arity
idArity id = arityLowerBound (idArityInfo id)
318

319 320
setIdArityInfo :: Id -> ArityInfo -> Id
setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
321

322 323
	---------------------------------
	-- STRICTNESS
324 325
idStrictness :: Id -> StrictnessInfo
idStrictness id = strictnessInfo (idInfo id)
326

327
setIdStrictness :: Id -> StrictnessInfo -> Id
328
setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
329

330 331
-- isBottomingId returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
332
isBottomingId id = isBottomingStrictness (idStrictness id)
333

334 335
	---------------------------------
	-- WORKER ID
336 337
idWorkerInfo :: Id -> WorkerInfo
idWorkerInfo id = workerInfo (idInfo id)
338 339

setIdWorkerInfo :: Id -> WorkerInfo -> Id
340
setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
341

342 343
	---------------------------------
	-- UNFOLDING
344 345
idUnfolding :: Id -> Unfolding
idUnfolding id = unfoldingInfo (idInfo id)
346

347
setIdUnfolding :: Id -> Unfolding -> Id
348
setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
sof's avatar
sof committed
349

350 351
	---------------------------------
	-- DEMAND
352 353
idDemandInfo :: Id -> Demand
idDemandInfo id = demandInfo (idInfo id)
354

355
setIdDemandInfo :: Id -> Demand -> Id
356
setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
357

358 359
	---------------------------------
	-- SPECIALISATION
360 361
idSpecialisation :: Id -> CoreRules
idSpecialisation id = specInfo (idInfo id)
362

363 364
setIdSpecialisation :: Id -> CoreRules -> Id
setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
365

366 367
	---------------------------------
	-- CAF INFO
368 369
idCafInfo :: Id -> CafInfo
idCafInfo id = cafInfo (idInfo id)
370

371
setIdCafInfo :: Id -> CafInfo -> Id
372
setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
373 374 375

	---------------------------------
	-- CPR INFO
376 377
idCprInfo :: Id -> CprInfo
idCprInfo id = cprInfo (idInfo id)
378 379

setIdCprInfo :: Id -> CprInfo -> Id
380
setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
381 382 383

	---------------------------------
	-- Occcurrence INFO
384 385
idOccInfo :: Id -> OccInfo
idOccInfo id = occInfo (idInfo id)
386 387 388

setIdOccInfo :: Id -> OccInfo -> Id
setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
389 390
\end{code}

sof's avatar
sof committed
391

392 393 394 395
	---------------------------------
	-- INLINING
The inline pragma tells us to be very keen to inline this Id, but it's still
OK not to if optimisation is switched off.
396 397

\begin{code}
398 399
idInlinePragma :: Id -> InlinePragInfo
idInlinePragma id = inlinePragInfo (idInfo id)
400

401
setInlinePragma :: Id -> InlinePragInfo -> Id
402
setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
403

404
modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
405
modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
406
\end{code}
407 408 409 410 411


	---------------------------------
	-- ONE-SHOT LAMBDAS
\begin{code}
412 413 414
idLBVarInfo :: Id -> LBVarInfo
idLBVarInfo id = lbvarInfo (idInfo id)

415
isOneShotLambda :: Id -> Bool
416
isOneShotLambda id = case idLBVarInfo id of
417
			IsOneShotLambda -> True
418 419 420
			NoLBVarInfo	-> case splitTyConApp_maybe (idType id) of
						Just (tycon,_) -> tycon == statePrimTyCon
						other	       -> False
421 422 423 424 425 426 427 428 429 430 431
	-- The last clause is a gross hack.  It claims that 
	-- every function over realWorldStatePrimTy is a one-shot
	-- function.  This is pretty true in practice, and makes a big
	-- difference.  For example, consider
	--	a `thenST` \ r -> ...E...
	-- The early full laziness pass, if it doesn't know that r is one-shot
	-- will pull out E (let's say it doesn't mention r) to give
	--	let lvl = E in a `thenST` \ r -> ...lvl...
	-- When `thenST` gets inlined, we end up with
	--	let lvl = E in \s -> case a s of (r, s') -> ...lvl...
	-- and we don't re-inline E.
432
	--
433 434
	-- It would be better to spot that r was one-shot to start with, but
	-- I don't want to rely on that.
435 436 437
	--
	-- Another good example is in fill_in in PrelPack.lhs.  We should be able to
	-- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
438 439 440

setOneShotLambda :: Id -> Id
setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
441 442 443 444 445 446 447 448 449

clearOneShotLambda :: Id -> Id
clearOneShotLambda id 
  | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
  | otherwise	       = id			

-- But watch out: this may change the type of something else
--	f = \x -> e
-- If we change the one-shot-ness of x, f's type changes
450
\end{code}
451 452 453 454 455 456 457 458 459

\begin{code}
zapFragileIdInfo :: Id -> Id
zapFragileIdInfo id = maybeModifyIdInfo zapFragileInfo id

zapLamIdInfo :: Id -> Id
zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
\end{code}

460 461 462 463 464 465 466 467 468 469