ghc/compiler/basicTypes/Var.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section{@Vars@: Variables}
   5
   6 \begin{code}
   7 module Var (
   8         Var,
   9         varName, varUnique,
  10         setVarName, setVarUnique, setVarOcc,
  11
  12         -- TyVars
  13         TyVar, mkTyVar, mkTcTyVar,
  14         tyVarName, tyVarKind,
  15         setTyVarName, setTyVarUnique,
  16         tcTyVarDetails,
  17
  18         -- Ids
  19         Id, DictId,
  20         idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
  21         setIdName, setIdUnique, setIdType, setIdInfo, lazySetIdInfo,
  22         setIdLocalExported, zapSpecPragmaId,
  23
  24         globalIdDetails, globaliseId,
  25
  26         mkLocalId, mkExportedLocalId, mkSpecPragmaId,
  27         mkGlobalId,
  28
  29         isTyVar, isTcTyVar, isId, isLocalVar, isLocalId,
  30         isGlobalId, isExportedId, isSpecPragmaId,
  31         mustHaveLocalBinding
  32     ) where
  33
  34 #include "HsVersions.h"
  35
  36 import {-# SOURCE #-}   TypeRep( Type )
  37 import {-# SOURCE #-}   TcType( TcTyVarDetails )
  38 import {-# SOURCE #-}   IdInfo( GlobalIdDetails, notGlobalId, IdInfo, seqIdInfo )
  39
  40 import Name             ( Name, OccName, NamedThing(..),
  41                           setNameUnique, setNameOcc, nameUnique
  42                         )
  43 import Kind             ( Kind )
  44 import Unique           ( Unique, Uniquable(..), mkUniqueGrimily, getKey# )
  45 import FastTypes
  46 import Outputable
  47 \end{code}
  48
  49
  50 %************************************************************************
  51 %*                                                                      *
  52 \subsection{The main data type declarations}
  53 %*                                                                      *
  54 %************************************************************************
  55
  56
  57 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
  58 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
  59 strictness).  The essential info about different kinds of @Vars@ is
  60 in its @VarDetails@.
  61
  62 \begin{code}
  63 data Var
  64   = TyVar {
  65         varName    :: !Name,
  66         realUnique :: FastInt,          -- Key for fast comparison
  67                                         -- Identical to the Unique in the name,
  68                                         -- cached here for speed
  69         tyVarKind :: Kind }
  70
  71   | TcTyVar {                           -- Used only during type inference
  72         varName        :: !Name,
  73         realUnique     :: FastInt,
  74         tyVarKind      :: Kind,
  75         tcTyVarDetails :: TcTyVarDetails }
  76
  77   | GlobalId {                  -- Used for imported Ids, dict selectors etc
  78         varName    :: !Name,
  79         realUnique :: FastInt,
  80         idType     :: Type,
  81         idInfo     :: IdInfo,
  82         gblDetails :: GlobalIdDetails }
  83
  84   | LocalId {                   -- Used for locally-defined Ids (see NOTE below)
  85         varName    :: !Name,
  86         realUnique :: FastInt,
  87         idType     :: Type,
  88         idInfo     :: IdInfo,
  89         lclDetails :: LocalIdDetails }
  90
  91 data LocalIdDetails
  92   = NotExported -- Not exported
  93   | Exported    -- Exported
  94   | SpecPragma  -- Not exported, but not to be discarded either
  95                 -- It's unclean that this is so deeply built in
  96 \end{code}
  97
  98 LocalId and GlobalId
  99 ~~~~~~~~~~~~~~~~~~~~
 100 A GlobalId is
 101   * always a constant (top-level)
 102   * imported, or data constructor, or primop, or record selector
 103   * has a Unique that is globally unique across the whole
 104     GHC invocation (a single invocation may compile multiple modules)
 105
 106 A LocalId is
 107   * bound within an expression (lambda, case, local let(rec))
 108   * or defined at top level in the module being compiled
 109
 110 After CoreTidy, top-level LocalIds are turned into GlobalIds
 111
 112
 113 \begin{code}
 114 instance Outputable Var where
 115   ppr var = ppr (varName var)
 116
 117 instance Show Var where
 118   showsPrec p var = showsPrecSDoc p (ppr var)
 119
 120 instance NamedThing Var where
 121   getName = varName
 122
 123 instance Uniquable Var where
 124   getUnique = varUnique
 125
 126 instance Eq Var where
 127     a == b = realUnique a ==# realUnique b
 128
 129 instance Ord Var where
 130     a <= b = realUnique a <=# realUnique b
 131     a <  b = realUnique a <#  realUnique b
 132     a >= b = realUnique a >=# realUnique b
 133     a >  b = realUnique a >#  realUnique b
 134     a `compare` b = varUnique a `compare` varUnique b
 135 \end{code}
 136
 137
 138 \begin{code}
 139 varUnique :: Var -> Unique
 140 varUnique var = mkUniqueGrimily (iBox (realUnique var))
 141
 142 setVarUnique :: Var -> Unique -> Var
 143 setVarUnique var uniq
 144   = var { realUnique = getKey# uniq,
 145           varName = setNameUnique (varName var) uniq }
 146
 147 setVarName :: Var -> Name -> Var
 148 setVarName var new_name
 149   = var { realUnique = getKey# (getUnique new_name),
 150           varName = new_name }
 151
 152 setVarOcc :: Var -> OccName -> Var
 153 setVarOcc var new_occ
 154   = var { varName = setNameOcc (varName var) new_occ }
 155 \end{code}
 156
 157
 158 %************************************************************************
 159 %*                                                                      *
 160 \subsection{Type variables}
 161 %*                                                                      *
 162 %************************************************************************
 163
 164 \begin{code}
 165 type TyVar = Var
 166
 167 tyVarName = varName
 168
 169 setTyVarUnique = setVarUnique
 170 setTyVarName   = setVarName
 171 \end{code}
 172
 173 \begin{code}
 174 mkTyVar :: Name -> Kind -> TyVar
 175 mkTyVar name kind = TyVar { varName    = name
 176                           , realUnique = getKey# (nameUnique name)
 177                           , tyVarKind  = kind
 178                         }
 179
 180 mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
 181 mkTcTyVar name kind details
 182   = TcTyVar {   varName    = name,
 183                 realUnique = getKey# (nameUnique name),
 184                 tyVarKind  = kind,
 185                 tcTyVarDetails = details
 186         }
 187 \end{code}
 188
 189
 190 %************************************************************************
 191 %*                                                                      *
 192 \subsection{Id Construction}
 193 %*                                                                      *
 194 %************************************************************************
 195
 196 Most Id-related functions are in Id.lhs and MkId.lhs
 197
 198 \begin{code}
 199 type Id     = Var
 200 type DictId = Id
 201 \end{code}
 202
 203 \begin{code}
 204 idName    = varName
 205 idUnique  = varUnique
 206
 207 setIdUnique :: Id -> Unique -> Id
 208 setIdUnique = setVarUnique
 209
 210 setIdName :: Id -> Name -> Id
 211 setIdName = setVarName
 212
 213 setIdType :: Id -> Type -> Id
 214 setIdType id ty = id {idType = ty}
 215
 216 setIdLocalExported :: Id -> Id
 217 -- It had better be a LocalId already
 218 setIdLocalExported id = id { lclDetails = Exported }
 219
 220 globaliseId :: GlobalIdDetails -> Id -> Id
 221 -- If it's a local, make it global
 222 globaliseId details id = GlobalId { varName    = varName id,
 223                                     realUnique = realUnique id,
 224                                     idType     = idType id,
 225                                     idInfo     = idInfo id,
 226                                     gblDetails = details }
 227
 228 zapSpecPragmaId :: Id -> Id
 229 zapSpecPragmaId id
 230   | isSpecPragmaId id = id {lclDetails = NotExported}
 231   | otherwise         = id
 232
 233 lazySetIdInfo :: Id -> IdInfo -> Id
 234 lazySetIdInfo id info = id {idInfo = info}
 235
 236 setIdInfo :: Id -> IdInfo -> Id
 237 setIdInfo id info = seqIdInfo info `seq` id {idInfo = info}
 238         -- Try to avoid spack leaks by seq'ing
 239
 240 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 241 modifyIdInfo fn id
 242   = seqIdInfo new_info `seq` id {idInfo = new_info}
 243   where
 244     new_info = fn (idInfo id)
 245
 246 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 247 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 248 maybeModifyIdInfo fn id
 249   = case fn (idInfo id) of
 250         Nothing       -> id
 251         Just new_info -> id {idInfo = new_info}
 252 \end{code}
 253
 254 %************************************************************************
 255 %*                                                                      *
 256 \subsection{Predicates over variables
 257 %*                                                                      *
 258 %************************************************************************
 259
 260 \begin{code}
 261 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
 262 mkGlobalId details name ty info
 263   = GlobalId {  varName    = name,
 264                 realUnique = getKey# (nameUnique name),         -- Cache the unique
 265                 idType     = ty,
 266                 gblDetails = details,
 267                 idInfo     = info }
 268
 269 mk_local_id :: Name -> Type -> LocalIdDetails -> IdInfo -> Id
 270 mk_local_id name ty details info
 271   = LocalId {   varName    = name,
 272                 realUnique = getKey# (nameUnique name),         -- Cache the unique
 273                 idType     = ty,
 274                 lclDetails = details,
 275                 idInfo     = info }
 276
 277 mkLocalId :: Name -> Type -> IdInfo -> Id
 278 mkLocalId name ty info = mk_local_id name ty NotExported info
 279
 280 mkExportedLocalId :: Name -> Type -> IdInfo -> Id
 281 mkExportedLocalId name ty info = mk_local_id name ty Exported info
 282
 283 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
 284 mkSpecPragmaId name ty info = mk_local_id name ty SpecPragma info
 285 \end{code}
 286
 287 \begin{code}
 288 isTyVar, isTcTyVar                       :: Var -> Bool
 289 isId, isLocalVar, isLocalId              :: Var -> Bool
 290 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
 291 mustHaveLocalBinding                     :: Var -> Bool
 292
 293 isTyVar (TyVar {})   = True
 294 isTyVar (TcTyVar {}) = True
 295 isTyVar other        = False
 296
 297 isTcTyVar (TcTyVar {}) = True
 298 isTcTyVar other        = False
 299
 300 isId (LocalId {})  = True
 301 isId (GlobalId {}) = True
 302 isId other         = False
 303
 304 isLocalId (LocalId {}) = True
 305 isLocalId other        = False
 306
 307 -- isLocalVar returns True for type variables as well as local Ids
 308 -- These are the variables that we need to pay attention to when finding free
 309 -- variables, or doing dependency analysis.
 310 isLocalVar (GlobalId {}) = False
 311 isLocalVar other         = True
 312
 313 -- mustHaveLocalBinding returns True of Ids and TyVars
 314 -- that must have a binding in this module.  The converse
 315 -- is not quite right: there are some GlobalIds that must have
 316 -- bindings, such as record selectors.  But that doesn't matter,
 317 -- because it's only used for assertions
 318 mustHaveLocalBinding var = isLocalVar var
 319
 320 isGlobalId (GlobalId {}) = True
 321 isGlobalId other         = False
 322
 323 -- isExportedId means "don't throw this away"
 324 isExportedId (GlobalId {}) = True
 325 isExportedId (LocalId {lclDetails = details})
 326   = case details of
 327         Exported   -> True
 328         SpecPragma -> True
 329         other      -> False
 330 isExportedId other = False
 331
 332 isSpecPragmaId (LocalId {lclDetails = SpecPragma}) = True
 333 isSpecPragmaId other = False
 334 \end{code}
 335
 336 \begin{code}
 337 globalIdDetails :: Var -> GlobalIdDetails
 338 -- Works OK on local Ids too, returning notGlobalId
 339 globalIdDetails (GlobalId {gblDetails = details}) = details
 340 globalIdDetails other                             = notGlobalId
 341 \end{code}
 342