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