Id.lhs 12.7 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 12
	mkId, mkVanillaId, mkSysLocal, mkUserLocal,
	mkTemplateLocals, 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 32 33
	isPrimOpId, isPrimOpId_maybe, 
	isDataConId, isDataConId_maybe, isDataConWrapId, isDataConWrapId_maybe,
	isBottomingId,
34
	isExportedId, isUserExportedId,
35 36 37 38 39
	hasNoBinding,

	-- Inline pragma stuff
	idInlinePragma, setInlinePragma, modifyInlinePragma, 

40

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

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

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

67
    ) where
68

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


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

import IdInfo 

86
import Demand		( Demand, isStrict, wwLazy )
sof's avatar
sof committed
87
import Name	 	( Name, OccName,
88
			  mkSysLocalName, mkLocalName,
89 90
			  isWiredInName, isUserExportedName,
			  getOccName, isIPOcc
sof's avatar
sof committed
91
			) 
92
import OccName		( UserFS )
93
import PrimRep		( PrimRep )
94
import PrimOp		( PrimOp, primOpIsCheap )
95
import TysPrim		( statePrimTyCon )
96
import FieldLabel	( FieldLabel )
97
import SrcLoc		( SrcLoc )
98
import Unique		( Unique, mkBuiltinUnique, getBuiltinUniques )
99
import Outputable
100

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

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


115

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

122 123 124 125
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 
126

127 128 129 130 131 132 133
\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}
134

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

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

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

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}
153 154
-- "Wild Id" typically used when you need a binder that you don't expect to use
mkWildId :: Type -> Id
155
mkWildId ty = mkSysLocal SLIT("wild") (mkBuiltinUnique 1) ty
156 157

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

mkTemplateLocal :: Int -> Type -> Id
mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
165 166 167
\end{code}


168 169 170 171 172 173 174
%************************************************************************
%*									*
\subsection[Id-general-funs]{General @Id@-related functions}
%*									*
%************************************************************************

\begin{code}
175
idFreeTyVars :: Id -> TyVarSet
176
idFreeTyVars id = tyVarsOfType (idType id)
177

178
setIdType :: Id -> Type -> Id
179
	-- Add free tyvar info to the type
180
setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
sof's avatar
sof committed
181

182 183
idPrimRep :: Id -> PrimRep
idPrimRep id = typePrimRep (idType id)
184 185 186 187 188
\end{code}


%************************************************************************
%*									*
189
\subsection{Special Ids}
190 191 192
%*									*
%************************************************************************

sof's avatar
sof committed
193
\begin{code}
194 195 196 197 198 199 200
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

201
recordSelectorFieldLabel :: Id -> FieldLabel
202
recordSelectorFieldLabel id = case idFlavour id of
203
				RecordSelId lbl -> lbl
sof's avatar
sof committed
204

205
isRecordSelector id = case idFlavour id of
206 207
			RecordSelId lbl -> True
			other	  	-> False
sof's avatar
sof committed
208

209 210 211 212 213 214 215 216 217 218 219
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
220

221
isDataConId_maybe id = case idFlavour id of
222 223
			  DataConId con -> Just con
			  other	        -> Nothing
sof's avatar
sof committed
224

225 226 227
isDataConWrapId_maybe id = case idFlavour id of
				  DataConWrapId con -> Just con
				  other	            -> Nothing
228

229 230 231
isDataConWrapId id = case idFlavour id of
			DataConWrapId con -> True
			other	          -> False
232

233 234 235 236
isSpecPragmaId id = case idFlavour id of
			SpecPragmaId -> True
			other	     -> False

237
hasNoBinding id = case idFlavour id of
238 239 240
			DataConId _ -> True
			PrimOpId _  -> True
			other	    -> False
241
	-- hasNoBinding returns True of an Id which may not have a
242 243 244
	-- binding, even though it is defined in this module.  Notably,
	-- the constructors of a dictionary are in this situation.

245 246 247 248 249 250 251 252 253 254 255
-- Don't drop a binding for an exported Id,
-- if it otherwise looks dead.  
isExportedId :: Id -> Bool
isExportedId id = case idFlavour id of
			VanillaId -> False
			other	  -> True	-- All the others are no-discard

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

258

259 260 261 262 263 264 265 266 267 268 269 270
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
  | isWiredInName (idName id)
  = True

  | otherwise
  = case idFlavour id of
271 272 273 274 275
	RecordSelId _   -> True	-- Includes dictionary selectors
        PrimOpId _      -> True
        DataConId _     -> True
	DataConWrapId _ -> True
		-- These are are implied by their type or class decl;
276 277 278 279 280
		-- 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!
281 282 283 284 285 286

-- 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
287 288 289 290
\end{code}

\begin{code}
isDeadBinder :: Id -> Bool
291
isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
292
		  | otherwise = False	-- TyVars count as not dead
293 294

isIP id = isIPOcc (getOccName id)
295 296 297
\end{code}


298 299
%************************************************************************
%*									*
300
\subsection{IdInfo stuff}
301 302 303
%*									*
%************************************************************************

304
\begin{code}
305 306
	---------------------------------
	-- ARITY
307 308 309 310 311
idArityInfo :: Id -> ArityInfo
idArityInfo id = arityInfo (idInfo id)

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

313 314
setIdArityInfo :: Id -> ArityInfo -> Id
setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
315

316 317
	---------------------------------
	-- STRICTNESS
318 319
idStrictness :: Id -> StrictnessInfo
idStrictness id = strictnessInfo (idInfo id)
320

321
setIdStrictness :: Id -> StrictnessInfo -> Id
322
setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
323

324 325
-- isBottomingId returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
326
isBottomingId id = isBottomingStrictness (idStrictness id)
327

328 329
	---------------------------------
	-- WORKER ID
330 331
idWorkerInfo :: Id -> WorkerInfo
idWorkerInfo id = workerInfo (idInfo id)
332 333

setIdWorkerInfo :: Id -> WorkerInfo -> Id
334
setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
335

336 337
	---------------------------------
	-- UNFOLDING
338 339
idUnfolding :: Id -> Unfolding
idUnfolding id = unfoldingInfo (idInfo id)
340

341
setIdUnfolding :: Id -> Unfolding -> Id
342
setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
sof's avatar
sof committed
343

344 345
	---------------------------------
	-- DEMAND
346 347
idDemandInfo :: Id -> Demand
idDemandInfo id = demandInfo (idInfo id)
348

349
setIdDemandInfo :: Id -> Demand -> Id
350
setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
351

352 353
	---------------------------------
	-- SPECIALISATION
354 355
idSpecialisation :: Id -> CoreRules
idSpecialisation id = specInfo (idInfo id)
356

357 358
setIdSpecialisation :: Id -> CoreRules -> Id
setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
359

360 361
	---------------------------------
	-- CAF INFO
362 363
idCafInfo :: Id -> CafInfo
idCafInfo id = cafInfo (idInfo id)
364

365
setIdCafInfo :: Id -> CafInfo -> Id
366
setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
367 368 369

	---------------------------------
	-- CPR INFO
370 371
idCprInfo :: Id -> CprInfo
idCprInfo id = cprInfo (idInfo id)
372 373

setIdCprInfo :: Id -> CprInfo -> Id
374
setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
375 376 377

	---------------------------------
	-- Occcurrence INFO
378 379
idOccInfo :: Id -> OccInfo
idOccInfo id = occInfo (idInfo id)
380 381 382

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

sof's avatar
sof committed
385

386 387 388 389
	---------------------------------
	-- 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.
390 391

\begin{code}
392 393
idInlinePragma :: Id -> InlinePragInfo
idInlinePragma id = inlinePragInfo (idInfo id)
394

395
setInlinePragma :: Id -> InlinePragInfo -> Id
396
setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
397

398
modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
399
modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
400
\end{code}
401 402 403 404 405


	---------------------------------
	-- ONE-SHOT LAMBDAS
\begin{code}
406 407 408
idLBVarInfo :: Id -> LBVarInfo
idLBVarInfo id = lbvarInfo (idInfo id)

409
isOneShotLambda :: Id -> Bool
410
isOneShotLambda id = case idLBVarInfo id of
411
			IsOneShotLambda -> True
412 413 414
			NoLBVarInfo	-> case splitTyConApp_maybe (idType id) of
						Just (tycon,_) -> tycon == statePrimTyCon
						other	       -> False
415 416 417 418 419 420 421 422 423 424 425
	-- 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.
426
	--
427 428
	-- It would be better to spot that r was one-shot to start with, but
	-- I don't want to rely on that.
429 430 431
	--
	-- 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.
432 433 434

setOneShotLambda :: Id -> Id
setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
435 436 437 438 439 440 441 442 443

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
444
\end{code}
445 446 447 448 449 450 451 452 453

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

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