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