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