ghc/compiler/basicTypes/Id.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[Id]{@Ids@: Value and constructor identifiers}
   5
   6 \begin{code}
   7 module Id (
   8         Id, DictId,
   9
  10         -- Simple construction
  11         mkId, mkVanillaId, mkSysLocal, mkUserLocal,
  12         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,
  26         exportWithOrigOccName,
  27         externallyVisibleId,
  28         idFreeTyVars,
  29         isIP,
  30
  31         -- Inline pragma stuff
  32         getInlinePragma, setInlinePragma, modifyInlinePragma,
  33
  34         isSpecPragmaId, isRecordSelector,
  35         isPrimitiveId_maybe, isDataConId_maybe,
  36         isConstantId, isConstantId_maybe, isBottomingId, idAppIsBottom,
  37         isExportedId, isUserExportedId,
  38         mayHaveNoBinding,
  39
  40         -- One shot lambda stuff
  41         isOneShotLambda, setOneShotLambda, clearOneShotLambda,
  42
  43         -- IdInfo stuff
  44         setIdUnfolding,
  45         setIdArity,
  46         setIdDemandInfo,
  47         setIdStrictness,
  48         setIdWorkerInfo,
  49         setIdSpecialisation,
  50         setIdUpdateInfo,
  51         setIdCafInfo,
  52         setIdCprInfo,
  53         setIdOccInfo,
  54
  55         getIdArity,
  56         getIdDemandInfo,
  57         getIdStrictness,
  58         getIdWorkerInfo,
  59         getIdUnfolding,
  60         getIdSpecialisation,
  61         getIdUpdateInfo,
  62         getIdCafInfo,
  63         getIdCprInfo,
  64         getIdOccInfo
  65
  66     ) where
  67
  68 #include "HsVersions.h"
  69
  70 import {-# SOURCE #-} CoreUnfold ( Unfolding )
  71 import {-# SOURCE #-} CoreSyn    ( CoreRules )
  72
  73 import Var              ( Id, DictId,
  74                           isId, mkIdVar,
  75                           idName, idType, idUnique, idInfo,
  76                           setIdName, setVarType, setIdUnique,
  77                           setIdInfo, lazySetIdInfo, modifyIdInfo, maybeModifyIdInfo,
  78                           externallyVisibleId
  79                         )
  80 import VarSet
  81 import Type             ( Type, tyVarsOfType, typePrimRep, addFreeTyVars, seqType, splitTyConApp_maybe )
  82
  83 import IdInfo
  84
  85 import Demand           ( Demand, isStrict, wwLazy )
  86 import Name             ( Name, OccName,
  87                           mkSysLocalName, mkLocalName,
  88                           isWiredInName, isUserExportedName,
  89                           getOccName, isIPOcc
  90                         )
  91 import OccName          ( UserFS )
  92 import Const            ( Con(..) )
  93 import PrimRep          ( PrimRep )
  94 import PrimOp           ( PrimOp )
  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           `setIdArity`,
 103           `setIdDemandInfo`,
 104           `setIdStrictness`,
 105           `setIdWorkerInfo`,
 106           `setIdSpecialisation`,
 107           `setIdUpdateInfo`,
 108           `setInlinePragma`,
 109           `getIdCafInfo`,
 110           `getIdCprInfo`
 111
 112         -- infixl so you can say (id `set` a `set` b)
 113 \end{code}
 114
 115
 116
 117 %************************************************************************
 118 %*                                                                      *
 119 \subsection{Simple Id construction}
 120 %*                                                                      *
 121 %************************************************************************
 122
 123 Absolutely all Ids are made by mkId.  It
 124         a) Pins free-tyvar-info onto the Id's type,
 125            where it can easily be found.
 126         b) Ensures that exported Ids are
 127
 128 \begin{code}
 129 mkId :: Name -> Type -> IdInfo -> Id
 130 mkId name ty info = mkIdVar name (addFreeTyVars ty) info'
 131                   where
 132                     info' | isUserExportedName name = setNoDiscardInfo info
 133                           | otherwise               = info
 134 \end{code}
 135
 136 \begin{code}
 137 mkVanillaId :: Name -> Type -> Id
 138 mkVanillaId name ty = mkId name ty vanillaIdInfo
 139
 140 -- SysLocal: for an Id being created by the compiler out of thin air...
 141 -- UserLocal: an Id with a name the user might recognize...
 142 mkUserLocal :: OccName -> Unique -> Type -> SrcLoc -> Id
 143 mkSysLocal  :: UserFS  -> Unique -> Type -> Id
 144
 145 mkSysLocal  fs uniq ty      = mkVanillaId (mkSysLocalName uniq fs)      ty
 146 mkUserLocal occ uniq ty loc = mkVanillaId (mkLocalName    uniq occ loc) ty
 147 \end{code}
 148
 149 Make some local @Ids@ for a template @CoreExpr@.  These have bogus
 150 @Uniques@, but that's OK because the templates are supposed to be
 151 instantiated before use.
 152
 153 \begin{code}
 154 -- "Wild Id" typically used when you need a binder that you don't expect to use
 155 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                                (getBuiltinUniques (length tys))
 162                                tys
 163
 164 mkTemplateLocal :: Int -> Type -> Id
 165 mkTemplateLocal i ty = mkSysLocal SLIT("tpl") (mkBuiltinUnique i) ty
 166 \end{code}
 167
 168
 169 %************************************************************************
 170 %*                                                                      *
 171 \subsection[Id-general-funs]{General @Id@-related functions}
 172 %*                                                                      *
 173 %************************************************************************
 174
 175 \begin{code}
 176 idFreeTyVars :: Id -> TyVarSet
 177 idFreeTyVars id = tyVarsOfType (idType id)
 178
 179 setIdType :: Id -> Type -> Id
 180         -- Add free tyvar info to the type
 181 setIdType id ty = seqType ty `seq` setVarType id (addFreeTyVars ty)
 182
 183 idPrimRep :: Id -> PrimRep
 184 idPrimRep id = typePrimRep (idType id)
 185 \end{code}
 186
 187
 188 %************************************************************************
 189 %*                                                                      *
 190 \subsection{Special Ids}
 191 %*                                                                      *
 192 %************************************************************************
 193
 194 \begin{code}
 195 idFlavour :: Id -> IdFlavour
 196 idFlavour id = flavourInfo (idInfo id)
 197
 198 setIdNoDiscard :: Id -> Id
 199 setIdNoDiscard id       -- Make an Id into a NoDiscardId, unless it is already
 200   = modifyIdInfo setNoDiscardInfo id
 201
 202 recordSelectorFieldLabel :: Id -> FieldLabel
 203 recordSelectorFieldLabel id = case idFlavour id of
 204                                 RecordSelId lbl -> lbl
 205
 206 isRecordSelector id = case idFlavour id of
 207                         RecordSelId lbl -> True
 208                         other           -> False
 209
 210 isPrimitiveId_maybe id = case idFlavour id of
 211                             ConstantId (PrimOp op) -> Just op
 212                             other                  -> Nothing
 213
 214 isDataConId_maybe id = case idFlavour id of
 215                           ConstantId (DataCon con) -> Just con
 216                           other                    -> Nothing
 217
 218 isConstantId id = case idFlavour id of
 219                     ConstantId _ -> True
 220                     other        -> False
 221
 222 isConstantId_maybe id = case idFlavour id of
 223                           ConstantId const -> Just const
 224                           other            -> Nothing
 225
 226 isSpecPragmaId id = case idFlavour id of
 227                         SpecPragmaId -> True
 228                         other        -> False
 229
 230 mayHaveNoBinding id = isConstantId id
 231         -- mayHaveNoBinding returns True of an Id which may not have a
 232         -- binding, even though it is defined in this module.  Notably,
 233         -- the constructors of a dictionary are in this situation.
 234         --
 235         -- mayHaveNoBinding returns True of some things that *do* have a local binding,
 236         -- so it's only an approximation.  That's ok... it's only use for assertions.
 237
 238 -- Don't drop a binding for an exported Id,
 239 -- if it otherwise looks dead.
 240 isExportedId :: Id -> Bool
 241 isExportedId id = case idFlavour id of
 242                         VanillaId -> False
 243                         other     -> True       -- All the others are no-discard
 244
 245 -- Say if an Id was exported by the user
 246 -- Implies isExportedId (see mkId above)
 247 isUserExportedId :: Id -> Bool
 248 isUserExportedId id = isUserExportedName (idName id)
 249 \end{code}
 250
 251
 252 omitIfaceSigForId tells whether an Id's info is implied by other declarations,
 253 so we don't need to put its signature in an interface file, even if it's mentioned
 254 in some other interface unfolding.
 255
 256 \begin{code}
 257 omitIfaceSigForId :: Id -> Bool
 258 omitIfaceSigForId id
 259   | isWiredInName (idName id)
 260   = True
 261
 262   | otherwise
 263   = case idFlavour id of
 264         RecordSelId _  -> True  -- Includes dictionary selectors
 265         ConstantId _   -> True
 266                 -- ConstantIds are implied by their type or class decl;
 267                 -- remember that all type and class decls appear in the interface file.
 268                 -- The dfun id must *not* be omitted, because it carries version info for
 269                 -- the instance decl
 270
 271         other          -> False -- Don't omit!
 272
 273 -- Certain names must be exported with their original occ names, because
 274 -- these names are bound by either a class declaration or a data declaration
 275 -- or an explicit user export.
 276 exportWithOrigOccName :: Id -> Bool
 277 exportWithOrigOccName id = omitIfaceSigForId id || isUserExportedId id
 278
 279 isIP id = isIPOcc (getOccName id)
 280 \end{code}
 281
 282
 283
 284 %************************************************************************
 285 %*                                                                      *
 286 \subsection{IdInfo stuff}
 287 %*                                                                      *
 288 %************************************************************************
 289
 290 \begin{code}
 291         ---------------------------------
 292         -- ARITY
 293 getIdArity :: Id -> ArityInfo
 294 getIdArity id = arityInfo (idInfo id)
 295
 296 setIdArity :: Id -> ArityInfo -> Id
 297 setIdArity id arity = modifyIdInfo (`setArityInfo` arity) id
 298
 299         ---------------------------------
 300         -- STRICTNESS
 301 getIdStrictness :: Id -> StrictnessInfo
 302 getIdStrictness id = strictnessInfo (idInfo id)
 303
 304 setIdStrictness :: Id -> StrictnessInfo -> Id
 305 setIdStrictness id strict_info = modifyIdInfo (`setStrictnessInfo` strict_info) id
 306
 307 -- isBottomingId returns true if an application to n args would diverge
 308 isBottomingId :: Id -> Bool
 309 isBottomingId id = isBottomingStrictness (strictnessInfo (idInfo id))
 310
 311 idAppIsBottom :: Id -> Int -> Bool
 312 idAppIsBottom id n = appIsBottom (strictnessInfo (idInfo id)) n
 313
 314         ---------------------------------
 315         -- WORKER ID
 316 getIdWorkerInfo :: Id -> WorkerInfo
 317 getIdWorkerInfo id = workerInfo (idInfo id)
 318
 319 setIdWorkerInfo :: Id -> WorkerInfo -> Id
 320 setIdWorkerInfo id work_info = modifyIdInfo (`setWorkerInfo` work_info) id
 321
 322         ---------------------------------
 323         -- UNFOLDING
 324 getIdUnfolding :: Id -> Unfolding
 325 getIdUnfolding id = unfoldingInfo (idInfo id)
 326
 327 setIdUnfolding :: Id -> Unfolding -> Id
 328 setIdUnfolding id unfolding = modifyIdInfo (`setUnfoldingInfo` unfolding) id
 329
 330         ---------------------------------
 331         -- DEMAND
 332 getIdDemandInfo :: Id -> Demand
 333 getIdDemandInfo id = demandInfo (idInfo id)
 334
 335 setIdDemandInfo :: Id -> Demand -> Id
 336 setIdDemandInfo id demand_info = modifyIdInfo (`setDemandInfo` demand_info) id
 337
 338         ---------------------------------
 339         -- UPDATE INFO
 340 getIdUpdateInfo :: Id -> UpdateInfo
 341 getIdUpdateInfo id = updateInfo (idInfo id)
 342
 343 setIdUpdateInfo :: Id -> UpdateInfo -> Id
 344 setIdUpdateInfo id upd_info = modifyIdInfo (`setUpdateInfo` upd_info) id
 345
 346         ---------------------------------
 347         -- SPECIALISATION
 348 getIdSpecialisation :: Id -> CoreRules
 349 getIdSpecialisation id = specInfo (idInfo id)
 350
 351 setIdSpecialisation :: Id -> CoreRules -> Id
 352 setIdSpecialisation id spec_info = modifyIdInfo (`setSpecInfo` spec_info) id
 353
 354         ---------------------------------
 355         -- CAF INFO
 356 getIdCafInfo :: Id -> CafInfo
 357 getIdCafInfo id = cafInfo (idInfo id)
 358
 359 setIdCafInfo :: Id -> CafInfo -> Id
 360 setIdCafInfo id caf_info = modifyIdInfo (`setCafInfo` caf_info) id
 361
 362         ---------------------------------
 363         -- CPR INFO
 364 getIdCprInfo :: Id -> CprInfo
 365 getIdCprInfo id = cprInfo (idInfo id)
 366
 367 setIdCprInfo :: Id -> CprInfo -> Id
 368 setIdCprInfo id cpr_info = modifyIdInfo (`setCprInfo` cpr_info) id
 369
 370         ---------------------------------
 371         -- Occcurrence INFO
 372 getIdOccInfo :: Id -> OccInfo
 373 getIdOccInfo id = occInfo (idInfo id)
 374
 375 setIdOccInfo :: Id -> OccInfo -> Id
 376 setIdOccInfo id occ_info = modifyIdInfo (`setOccInfo` occ_info) id
 377 \end{code}
 378
 379
 380         ---------------------------------
 381         -- INLINING
 382 The inline pragma tells us to be very keen to inline this Id, but it's still
 383 OK not to if optimisation is switched off.
 384
 385 \begin{code}
 386 getInlinePragma :: Id -> InlinePragInfo
 387 getInlinePragma id = inlinePragInfo (idInfo id)
 388
 389 setInlinePragma :: Id -> InlinePragInfo -> Id
 390 setInlinePragma id prag = modifyIdInfo (`setInlinePragInfo` prag) id
 391
 392 modifyInlinePragma :: Id -> (InlinePragInfo -> InlinePragInfo) -> Id
 393 modifyInlinePragma id fn = modifyIdInfo (\info -> info `setInlinePragInfo` (fn (inlinePragInfo info))) id
 394 \end{code}
 395
 396
 397         ---------------------------------
 398         -- ONE-SHOT LAMBDAS
 399 \begin{code}
 400 isOneShotLambda :: Id -> Bool
 401 isOneShotLambda id = case lbvarInfo (idInfo id) of
 402                         IsOneShotLambda -> True
 403                         NoLBVarInfo     -> case splitTyConApp_maybe (idType id) of
 404                                                 Just (tycon,_) -> tycon == statePrimTyCon
 405                                                 other          -> False
 406         -- The last clause is a gross hack.  It claims that
 407         -- every function over realWorldStatePrimTy is a one-shot
 408         -- function.  This is pretty true in practice, and makes a big
 409         -- difference.  For example, consider
 410         --      a `thenST` \ r -> ...E...
 411         -- The early full laziness pass, if it doesn't know that r is one-shot
 412         -- will pull out E (let's say it doesn't mention r) to give
 413         --      let lvl = E in a `thenST` \ r -> ...lvl...
 414         -- When `thenST` gets inlined, we end up with
 415         --      let lvl = E in \s -> case a s of (r, s') -> ...lvl...
 416         -- and we don't re-inline E.
 417         --
 418         -- It would be better to spot that r was one-shot to start with, but
 419         -- I don't want to rely on that.
 420         --
 421         -- Another good example is in fill_in in PrelPack.lhs.  We should be able to
 422         -- spot that fill_in has arity 2 (and when Keith is done, we will) but we can't yet.
 423
 424 setOneShotLambda :: Id -> Id
 425 setOneShotLambda id = modifyIdInfo (`setLBVarInfo` IsOneShotLambda) id
 426
 427 clearOneShotLambda :: Id -> Id
 428 clearOneShotLambda id
 429   | isOneShotLambda id = modifyIdInfo (`setLBVarInfo` NoLBVarInfo) id
 430   | otherwise          = id
 431
 432 -- But watch out: this may change the type of something else
 433 --      f = \x -> e
 434 -- If we change the one-shot-ness of x, f's type changes
 435 \end{code}
 436
 437 \begin{code}
 438 zapFragileIdInfo :: Id -> Id
 439 zapFragileIdInfo id = maybeModifyIdInfo zapFragileInfo id
 440
 441 zapLamIdInfo :: Id -> Id
 442 zapLamIdInfo id = maybeModifyIdInfo zapLamInfo id
 443 \end{code}
 444