Id.lhs 13.2 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 74
import CoreSyn		( Unfolding, CoreRules, CoreExpr, Expr(..),
			  AltCon (..), Alt, mkApps, Arg )
75
import BasicTypes	( Arity )
76 77 78 79
import Var		( Id, DictId,
			  isId, mkIdVar,
			  idName, idType, idUnique, idInfo,
			  setIdName, setVarType, setIdUnique, 
80 81
			  setIdInfo, lazySetIdInfo, modifyIdInfo, 
			  maybeModifyIdInfo,
82 83 84
			  externallyVisibleId
			)
import VarSet
85 86 87
import Type		( Type, tyVarsOfType, typePrimRep, addFreeTyVars, 
			  seqType, splitAlgTyConApp_maybe, mkTyVarTy,
			  mkTyConApp, splitTyConApp_maybe)
88 89 90

import IdInfo 

91
import Demand		( Demand, isStrict, wwLazy )
sof's avatar
sof committed
92
import Name	 	( Name, OccName,
93
			  mkSysLocalName, mkLocalName,
94
			  isUserExportedName, getOccName, isIPOcc
sof's avatar
sof committed
95
			) 
96
import OccName		( UserFS )
97
import PrimRep		( PrimRep )
98
import PrimOp		( PrimOp, primOpIsCheap )
99
import TysPrim		( statePrimTyCon )
100
import FieldLabel	( FieldLabel )
101
import SrcLoc		( SrcLoc )
102 103
import Unique		( Unique, mkBuiltinUnique, getBuiltinUniques, 
			  getNumBuiltinUniques )
104
import Outputable
105 106 107 108 109
import TyCon            ( TyCon, AlgTyConFlavour(..), ArgVrcs, mkSynTyCon, 
			  mkAlgTyConRep, tyConName, 
			  tyConTyVars, tyConDataCons )
import DataCon 		( DataCon, dataConWrapId, dataConOrigArgTys )
import Var 		( Var )
110
infixl 	1 `setIdUnfolding`,
111
	  `setIdArityInfo`,
112 113
	  `setIdDemandInfo`,
	  `setIdStrictness`,
114
	  `setIdWorkerInfo`,
115
	  `setIdSpecialisation`,
116
	  `setInlinePragma`,
117 118
	  `idCafInfo`,
	  `idCprInfo`
119

120
	-- infixl so you can say (id `set` a `set` b)
121 122 123
\end{code}


124

125 126
%************************************************************************
%*									*
127
\subsection{Simple Id construction}
128 129 130
%*									*
%************************************************************************

131 132 133 134
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 
135

136 137 138 139 140 141 142
\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}
143

144 145 146
\begin{code}
mkVanillaId :: Name -> Type -> Id
mkVanillaId name ty = mkId name ty vanillaIdInfo
147 148 149

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

153 154
mkSysLocal  fs uniq ty      = mkVanillaId (mkSysLocalName uniq fs)      ty
mkUserLocal occ uniq ty loc = mkVanillaId (mkLocalName    uniq occ loc) ty
155
\end{code}
156 157 158 159 160 161

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}
162 163
-- "Wild Id" typically used when you need a binder that you don't expect to use
mkWildId :: Type -> Id
164
mkWildId ty = mkSysLocal SLIT("wild") (mkBuiltinUnique 1) ty
165 166

-- "Template locals" typically used in unfoldings
167
mkTemplateLocals :: [Type] -> [Id]
168
mkTemplateLocals tys = zipWith (mkSysLocal SLIT("tpl"))
169 170
			       (getBuiltinUniques (length tys))
			       tys
171

172 173 174 175 176
mkTemplateLocalsNum :: Int -> [Type] -> [Id]
mkTemplateLocalsNum n tys = zipWith (mkSysLocal SLIT("tpl"))
			       (getNumBuiltinUniques n (length tys))
			       tys

177 178
mkTemplateLocal :: Int -> Type -> Id
mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
179 180 181
\end{code}


182 183 184 185 186 187 188
%************************************************************************
%*									*
\subsection[Id-general-funs]{General @Id@-related functions}
%*									*
%************************************************************************

\begin{code}
189
idFreeTyVars :: Id -> TyVarSet
190
idFreeTyVars id = tyVarsOfType (idType id)
191

192
setIdType :: Id -> Type -> Id
193
	-- Add free tyvar info to the type
194
setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
sof's avatar
sof committed
195

196 197
idPrimRep :: Id -> PrimRep
idPrimRep id = typePrimRep (idType id)
198 199 200 201 202
\end{code}


%************************************************************************
%*									*
203
\subsection{Special Ids}
204 205 206
%*									*
%************************************************************************

sof's avatar
sof committed
207
\begin{code}
208 209 210 211 212 213 214
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

215
recordSelectorFieldLabel :: Id -> FieldLabel
216
recordSelectorFieldLabel id = case idFlavour id of
217
				RecordSelId lbl -> lbl
sof's avatar
sof committed
218

219
isRecordSelector id = case idFlavour id of
220 221
			RecordSelId lbl -> True
			other	  	-> False
sof's avatar
sof committed
222

223 224 225 226 227 228 229 230 231 232 233
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
234

235
isDataConId_maybe id = case idFlavour id of
236 237
			  DataConId con -> Just con
			  other	        -> Nothing
sof's avatar
sof committed
238

239 240 241
isDataConWrapId_maybe id = case idFlavour id of
				  DataConWrapId con -> Just con
				  other	            -> Nothing
242

243 244 245
isDataConWrapId id = case idFlavour id of
			DataConWrapId con -> True
			other	          -> False
246

247 248 249 250
isSpecPragmaId id = case idFlavour id of
			SpecPragmaId -> True
			other	     -> False

251
hasNoBinding id = case idFlavour id of
252 253 254
			DataConId _ -> True
			PrimOpId _  -> True
			other	    -> False
255
	-- hasNoBinding returns True of an Id which may not have a
256 257 258
	-- binding, even though it is defined in this module.  Notably,
	-- the constructors of a dictionary are in this situation.

259 260 261 262 263 264 265 266 267 268 269
-- 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)
270 271
\end{code}

272

273 274 275 276 277 278 279 280 281
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
282 283 284 285 286
	RecordSelId _   -> True	-- Includes dictionary selectors
        PrimOpId _      -> True
        DataConId _     -> True
	DataConWrapId _ -> True
		-- These are are implied by their type or class decl;
287 288 289 290 291
		-- 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!
292 293 294 295 296 297

-- 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
298 299 300 301
\end{code}

\begin{code}
isDeadBinder :: Id -> Bool
302
isDeadBinder bndr | isId bndr = isDeadOcc (idOccInfo bndr)
303
		  | otherwise = False	-- TyVars count as not dead
304 305

isIP id = isIPOcc (getOccName id)
306 307 308
\end{code}


309 310
%************************************************************************
%*									*
311
\subsection{IdInfo stuff}
312 313 314
%*									*
%************************************************************************

315
\begin{code}
316 317
	---------------------------------
	-- ARITY
318 319 320 321 322
idArityInfo :: Id -> ArityInfo
idArityInfo id = arityInfo (idInfo id)

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

324 325
setIdArityInfo :: Id -> ArityInfo -> Id
setIdArityInfo id arity = modifyIdInfo (`setArityInfo` arity) id
326

327 328
	---------------------------------
	-- STRICTNESS
329 330
idStrictness :: Id -> StrictnessInfo
idStrictness id = strictnessInfo (idInfo id)
331

332
setIdStrictness :: Id -> StrictnessInfo -> Id
333
setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
334

335 336
-- isBottomingId returns true if an application to n args would diverge
isBottomingId :: Id -> Bool
337
isBottomingId id = isBottomingStrictness (idStrictness id)
338

339 340
	---------------------------------
	-- WORKER ID
341 342
idWorkerInfo :: Id -> WorkerInfo
idWorkerInfo id = workerInfo (idInfo id)
343 344

setIdWorkerInfo :: Id -> WorkerInfo -> Id
345
setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
346

347 348
	---------------------------------
	-- UNFOLDING
349 350
idUnfolding :: Id -> Unfolding
idUnfolding id = unfoldingInfo (idInfo id)
351

352
setIdUnfolding :: Id -> Unfolding -> Id
353
setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
sof's avatar
sof committed
354

355 356
	---------------------------------
	-- DEMAND
357 358
idDemandInfo :: Id -> Demand
idDemandInfo id = demandInfo (idInfo id)
359

360
setIdDemandInfo :: Id -> Demand -> Id
361
setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
362

363 364
	---------------------------------
	-- SPECIALISATION
365 366
idSpecialisation :: Id -> CoreRules
idSpecialisation id = specInfo (idInfo id)
367

368 369
setIdSpecialisation :: Id -> CoreRules -> Id
setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
370

371 372
	---------------------------------
	-- CAF INFO
373 374
idCafInfo :: Id -> CafInfo
idCafInfo id = cafInfo (idInfo id)
375

376
setIdCafInfo :: Id -> CafInfo -> Id
377
setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
378 379 380

	---------------------------------
	-- CPR INFO
381 382
idCprInfo :: Id -> CprInfo
idCprInfo id = cprInfo (idInfo id)
383 384

setIdCprInfo :: Id -> CprInfo -> Id
385
setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
386 387 388

	---------------------------------
	-- Occcurrence INFO
389 390
idOccInfo :: Id -> OccInfo
idOccInfo id = occInfo (idInfo id)
391 392 393

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

sof's avatar
sof committed
396

397 398 399 400
	---------------------------------
	-- 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.
401 402

\begin{code}
403 404
idInlinePragma :: Id -> InlinePragInfo
idInlinePragma id = inlinePragInfo (idInfo id)
405

406
setInlinePragma :: Id -> InlinePragInfo -> Id
407
setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
408

409
modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
410
modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
411
\end{code}
412 413 414 415 416


	---------------------------------
	-- ONE-SHOT LAMBDAS
\begin{code}
417 418 419
idLBVarInfo :: Id -> LBVarInfo
idLBVarInfo id = lbvarInfo (idInfo id)

420
isOneShotLambda :: Id -> Bool
421
isOneShotLambda id = case idLBVarInfo id of
422
			IsOneShotLambda -> True
423 424 425
			NoLBVarInfo	-> case splitTyConApp_maybe (idType id) of
						Just (tycon,_) -> tycon == statePrimTyCon
						other	       -> False
426 427 428 429 430 431 432 433 434 435 436
	-- 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.
437
	--
438 439
	-- It would be better to spot that r was one-shot to start with, but
	-- I don't want to rely on that.
440 441 442
	--
	-- 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.
443 444 445

setOneShotLambda :: Id -> Id
setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
446 447 448 449 450 451 452 453 454

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
455
\end{code}
456 457 458 459 460 461 462 463 464

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

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

465 466 467 468 469 470 471 472 473 474