compiler/basicTypes/Var.lhs

   1 %
   2 % (c) The University of Glasgow 2006
   3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   4 %
   5 \section{@Vars@: Variables}
   6
   7 \begin{code}
   8 module Var (
   9         Var,
  10         varName, varUnique, varType,
  11         setVarName, setVarUnique,
  12
  13         -- TyVars
  14         TyVar, mkTyVar, mkTcTyVar, mkWildCoVar,
  15         tyVarName, tyVarKind,
  16         setTyVarName, setTyVarUnique, setTyVarKind,
  17         tcTyVarDetails,
  18
  19         -- CoVars
  20         CoVar, coVarName, setCoVarUnique, setCoVarName, mkCoVar, isCoVar,
  21
  22         -- Ids
  23         Id, DictId,
  24         idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
  25         setIdName, setIdUnique, setIdType, setIdInfo, lazySetIdInfo,
  26         setIdExported, setIdNotExported,
  27
  28         globalIdDetails, globaliseId,
  29
  30         mkLocalId, mkExportedLocalId, mkGlobalId,
  31
  32         isTyVar, isTcTyVar, isId, isLocalVar, isLocalId,
  33         isGlobalId, isExportedId,
  34         mustHaveLocalBinding
  35     ) where
  36
  37 #include "HsVersions.h"
  38
  39 import {-# SOURCE #-}   TypeRep( Type, Kind )
  40 import {-# SOURCE #-}   TcType( TcTyVarDetails, pprTcTyVarDetails )
  41 import {-# SOURCE #-}   IdInfo( GlobalIdDetails, notGlobalId,
  42                                 IdInfo, seqIdInfo )
  43 import {-# SOURCE #-}   TypeRep( isCoercionKind )
  44
  45 import Name hiding (varName)
  46 import Unique
  47 import FastTypes
  48 import FastString
  49 import Outputable
  50 \end{code}
  51
  52
  53 %************************************************************************
  54 %*                                                                      *
  55 \subsection{The main data type declarations}
  56 %*                                                                      *
  57 %************************************************************************
  58
  59
  60 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
  61 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
  62 strictness).  The essential info about different kinds of @Vars@ is
  63 in its @VarDetails@.
  64
  65 \begin{code}
  66 data Var
  67   = TyVar {
  68         varName    :: !Name,
  69         realUnique :: FastInt,          -- Key for fast comparison
  70                                         -- Identical to the Unique in the name,
  71                                         -- cached here for speed
  72         varType       :: Kind,
  73         isCoercionVar :: Bool
  74  }
  75
  76   | TcTyVar {                           -- Used only during type inference
  77                                         -- Used for kind variables during
  78                                         -- inference, as well
  79         varName        :: !Name,
  80         realUnique     :: FastInt,
  81         varType        :: Kind,
  82         tcTyVarDetails :: TcTyVarDetails }
  83
  84   | GlobalId {                  -- Used for imported Ids, dict selectors etc
  85                                 -- See Note [GlobalId/LocalId] below
  86         varName    :: !Name,    -- Always an External or WiredIn Name
  87         realUnique :: FastInt,
  88         varType    :: Type,
  89         idInfo_    :: IdInfo,
  90         gblDetails :: GlobalIdDetails }
  91
  92   | LocalId {                   -- Used for locally-defined Ids
  93                                 -- See Note [GlobalId/LocalId] below
  94         varName    :: !Name,
  95         realUnique :: FastInt,
  96         varType    :: Type,
  97         idInfo_    :: IdInfo,
  98         lclDetails :: LocalIdDetails }
  99
 100 data LocalIdDetails
 101   = NotExported -- Not exported
 102   | Exported    -- Exported
 103   -- Exported Ids are kept alive;
 104   -- NotExported things may be discarded as dead code.
 105 \end{code}
 106
 107 Note [GlobalId/LocalId]
 108 ~~~~~~~~~~~~~~~~~~~~~~~
 109 A GlobalId is
 110   * always a constant (top-level)
 111   * imported, or data constructor, or primop, or record selector
 112   * has a Unique that is globally unique across the whole
 113     GHC invocation (a single invocation may compile multiple modules)
 114   * never treated as a candidate by the free-variable finder;
 115         it's a constant!
 116
 117 A LocalId is
 118   * bound within an expression (lambda, case, local let(rec))
 119   * or defined at top level in the module being compiled
 120   * always treated as a candidate by the free-variable finder
 121
 122 After CoreTidy, top-level LocalIds are turned into GlobalIds
 123
 124
 125 \begin{code}
 126 instance Outputable Var where
 127   ppr var = ppr (varName var) <+> ifPprDebug (brackets extra)
 128         where
 129           extra = case var of
 130                         GlobalId {} -> ptext SLIT("gid")
 131                         LocalId  {} -> ptext SLIT("lid")
 132                         TyVar    {} -> ptext SLIT("tv")
 133                         TcTyVar {tcTyVarDetails = details} -> pprTcTyVarDetails details
 134
 135 instance Show Var where
 136   showsPrec p var = showsPrecSDoc p (ppr var)
 137
 138 instance NamedThing Var where
 139   getName = varName
 140
 141 instance Uniquable Var where
 142   getUnique = varUnique
 143
 144 instance Eq Var where
 145     a == b = realUnique a ==# realUnique b
 146
 147 instance Ord Var where
 148     a <= b = realUnique a <=# realUnique b
 149     a <  b = realUnique a <#  realUnique b
 150     a >= b = realUnique a >=# realUnique b
 151     a >  b = realUnique a >#  realUnique b
 152     a `compare` b = varUnique a `compare` varUnique b
 153 \end{code}
 154
 155
 156 \begin{code}
 157 varUnique :: Var -> Unique
 158 varUnique var = mkUniqueGrimily (iBox (realUnique var))
 159
 160 setVarUnique :: Var -> Unique -> Var
 161 setVarUnique var uniq
 162   = var { realUnique = getKeyFastInt uniq,
 163           varName = setNameUnique (varName var) uniq }
 164
 165 setVarName :: Var -> Name -> Var
 166 setVarName var new_name
 167   = var { realUnique = getKeyFastInt (getUnique new_name),
 168           varName = new_name }
 169 \end{code}
 170
 171
 172 %************************************************************************
 173 %*                                                                      *
 174 \subsection{Type variables}
 175 %*                                                                      *
 176 %************************************************************************
 177
 178 \begin{code}
 179 type TyVar = Var
 180
 181 tyVarName :: TyVar -> Name
 182 tyVarName = varName
 183
 184 tyVarKind :: TyVar -> Kind
 185 tyVarKind = varType
 186
 187 setTyVarUnique :: TyVar -> Unique -> TyVar
 188 setTyVarUnique = setVarUnique
 189
 190 setTyVarName :: TyVar -> Name -> TyVar
 191 setTyVarName   = setVarName
 192
 193 setTyVarKind :: TyVar -> Kind -> TyVar
 194 setTyVarKind tv k = tv {varType = k}
 195 \end{code}
 196
 197 \begin{code}
 198 mkTyVar :: Name -> Kind -> TyVar
 199 mkTyVar name kind = ASSERT( not (isCoercionKind kind ) )
 200                     TyVar { varName    = name
 201                           , realUnique = getKeyFastInt (nameUnique name)
 202                           , varType  = kind
 203                           , isCoercionVar    = False
 204                         }
 205
 206 mkTcTyVar :: Name -> Kind -> TcTyVarDetails -> TyVar
 207 mkTcTyVar name kind details
 208   = -- TOM: no longer valid assertion?
 209     -- ASSERT( not (isCoercionKind kind) )
 210     TcTyVar {   varName    = name,
 211                 realUnique = getKeyFastInt (nameUnique name),
 212                 varType  = kind,
 213                 tcTyVarDetails = details
 214         }
 215 \end{code}
 216
 217 %************************************************************************
 218 %*                                                                      *
 219 \subsection{Coercion variables}
 220 %*                                                                      *
 221 %************************************************************************
 222
 223 \begin{code}
 224 type CoVar = Var        -- A coercion variable is simply a type
 225                         -- variable of kind (ty1 :=: ty2)
 226
 227 coVarName :: CoVar -> Name
 228 coVarName = varName
 229
 230 setCoVarUnique :: CoVar -> Unique -> CoVar
 231 setCoVarUnique = setVarUnique
 232
 233 setCoVarName :: CoVar -> Name -> CoVar
 234 setCoVarName   = setVarName
 235
 236 mkCoVar :: Name -> Kind -> CoVar
 237 mkCoVar name kind = ASSERT( isCoercionKind kind )
 238                     TyVar { varName       = name
 239                           , realUnique    = getKeyFastInt (nameUnique name)
 240                           , varType       = kind
 241                                 -- varType is always PredTy (EqPred t1 t2)
 242                           , isCoercionVar = True
 243                         }
 244
 245 mkWildCoVar :: Kind -> TyVar
 246 -- A type variable that is never referred to,
 247 -- so its unique doesn't matter
 248 mkWildCoVar kind
 249   = ASSERT( isCoercionKind kind )
 250     TyVar { varName = mkSysTvName wild_uniq FSLIT("co_wild"),
 251             realUnique = _ILIT(1),
 252             varType = kind,
 253             isCoercionVar = True }
 254   where
 255     wild_uniq = mkBuiltinUnique 1
 256 \end{code}
 257
 258 %************************************************************************
 259 %*                                                                      *
 260 \subsection{Id Construction}
 261 %*                                                                      *
 262 %************************************************************************
 263
 264 Most Id-related functions are in Id.lhs and MkId.lhs
 265
 266 \begin{code}
 267 type Id     = Var
 268 type DictId = Id
 269 \end{code}
 270
 271 \begin{code}
 272 idName   :: Id -> Name
 273 idUnique :: Id -> Unique
 274 idType   :: Id -> Kind
 275
 276 idName    = varName
 277 idUnique  = varUnique
 278 idType    = varType
 279
 280 setIdUnique :: Id -> Unique -> Id
 281 setIdUnique = setVarUnique
 282
 283 setIdName :: Id -> Name -> Id
 284 setIdName = setVarName
 285
 286 setIdType :: Id -> Type -> Id
 287 setIdType id ty = id {varType = ty}
 288
 289 setIdExported :: Id -> Id
 290 -- Can be called on GlobalIds, such as data cons and class ops,
 291 -- which are "born" as GlobalIds and automatically exported
 292 setIdExported id@(LocalId {}) = id { lclDetails = Exported }
 293 setIdExported other_id        = ASSERT( isId other_id ) other_id
 294
 295 setIdNotExported :: Id -> Id
 296 -- We can only do this to LocalIds
 297 setIdNotExported id = ASSERT( isLocalId id ) id { lclDetails = NotExported }
 298
 299 globaliseId :: GlobalIdDetails -> Id -> Id
 300 -- If it's a local, make it global
 301 globaliseId details id = GlobalId { varName    = varName id,
 302                                     realUnique = realUnique id,
 303                                     varType    = varType id,
 304                                     idInfo_    = idInfo id,
 305                                     gblDetails = details }
 306
 307 idInfo :: Id -> IdInfo
 308 idInfo (GlobalId {idInfo_ = info}) = info
 309 idInfo (LocalId  {idInfo_ = info}) = info
 310 idInfo other_var                   = pprPanic "idInfo" (ppr other_var)
 311
 312 lazySetIdInfo :: Id -> IdInfo -> Id
 313 lazySetIdInfo id info = id {idInfo_ = info}
 314
 315 setIdInfo :: Id -> IdInfo -> Id
 316 setIdInfo id info = seqIdInfo info `seq` id {idInfo_ = info}
 317         -- Try to avoid spack leaks by seq'ing
 318
 319 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 320 modifyIdInfo fn id
 321   = seqIdInfo new_info `seq` id {idInfo_ = new_info}
 322   where
 323     new_info = fn (idInfo id)
 324
 325 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 326 maybeModifyIdInfo :: Maybe IdInfo -> Id -> Id
 327 maybeModifyIdInfo (Just new_info) id = id {idInfo_ = new_info}
 328 maybeModifyIdInfo Nothing         id = id
 329 \end{code}
 330
 331 %************************************************************************
 332 %*                                                                      *
 333 \subsection{Predicates over variables
 334 %*                                                                      *
 335 %************************************************************************
 336
 337 \begin{code}
 338 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
 339 mkGlobalId details name ty info
 340   = GlobalId {  varName    = name,
 341                 realUnique = getKeyFastInt (nameUnique name),   -- Cache the unique
 342                 varType     = ty,
 343                 gblDetails = details,
 344                 idInfo_    = info }
 345
 346 mk_local_id :: Name -> Type -> LocalIdDetails -> IdInfo -> Id
 347 mk_local_id name ty details info
 348   = LocalId {   varName    = name,
 349                 realUnique = getKeyFastInt (nameUnique name),   -- Cache the unique
 350                 varType     = ty,
 351                 lclDetails = details,
 352                 idInfo_    = info }
 353
 354 mkLocalId :: Name -> Type -> IdInfo -> Id
 355 mkLocalId name ty info = mk_local_id name ty NotExported info
 356
 357 mkExportedLocalId :: Name -> Type -> IdInfo -> Id
 358 mkExportedLocalId name ty info = mk_local_id name ty Exported info
 359 \end{code}
 360
 361 \begin{code}
 362 isTyVar, isTcTyVar          :: Var -> Bool
 363 isId, isLocalVar, isLocalId :: Var -> Bool
 364 isGlobalId, isExportedId    :: Var -> Bool
 365 mustHaveLocalBinding        :: Var -> Bool
 366 isCoVar                     :: Var -> Bool
 367
 368 isTyVar (TyVar {})   = True
 369 isTyVar (TcTyVar {}) = True
 370 isTyVar _            = False
 371
 372 isTcTyVar (TcTyVar {}) = True
 373 isTcTyVar _            = False
 374
 375 isId (LocalId {})  = True
 376 isId (GlobalId {}) = True
 377 isId _             = False
 378
 379 isLocalId (LocalId {}) = True
 380 isLocalId _            = False
 381
 382 isCoVar (v@(TyVar {})) = isCoercionVar v
 383 isCoVar _              = False
 384
 385 -- isLocalVar returns True for type variables as well as local Ids
 386 -- These are the variables that we need to pay attention to when finding free
 387 -- variables, or doing dependency analysis.
 388 isLocalVar (GlobalId {}) = False
 389 isLocalVar _             = True
 390
 391 -- mustHaveLocalBinding returns True of Ids and TyVars
 392 -- that must have a binding in this module.  The converse
 393 -- is not quite right: there are some GlobalIds that must have
 394 -- bindings, such as record selectors.  But that doesn't matter,
 395 -- because it's only used for assertions
 396 mustHaveLocalBinding var = isLocalVar var
 397
 398 isGlobalId (GlobalId {}) = True
 399 isGlobalId _             = False
 400
 401 -- isExportedId means "don't throw this away"
 402 isExportedId (GlobalId {}) = True
 403 isExportedId (LocalId {lclDetails = details})
 404   = case details of
 405         Exported   -> True
 406         _          -> False
 407 isExportedId _ = False
 408 \end{code}
 409
 410 \begin{code}
 411 globalIdDetails :: Var -> GlobalIdDetails
 412 -- Works OK on local Ids too, returning notGlobalId
 413 globalIdDetails (GlobalId {gblDetails = details}) = details
 414 globalIdDetails _                                 = notGlobalId
 415 \end{code}
 416