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         setIdNoDiscard, 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, isExternallyVisibleName
  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
 108 A LocalId is
 109   * bound within an expression (lambda, case, local let(rec))
 110   * or defined at top level in the module being compiled
 111
 112 After CoreTidy, top-level LocalIds are turned into GlobalIds
 113
 114
 115 \begin{code}
 116 instance Outputable Var where
 117   ppr var = ppr (varName var)
 118
 119 instance Show Var where
 120   showsPrec p var = showsPrecSDoc p (ppr var)
 121
 122 instance NamedThing Var where
 123   getName = varName
 124
 125 instance Uniquable Var where
 126   getUnique = varUnique
 127
 128 instance Eq Var where
 129     a == b = realUnique a ==# realUnique b
 130
 131 instance Ord Var where
 132     a <= b = realUnique a <=# realUnique b
 133     a <  b = realUnique a <#  realUnique b
 134     a >= b = realUnique a >=# realUnique b
 135     a >  b = realUnique a >#  realUnique b
 136     a `compare` b = varUnique a `compare` varUnique b
 137 \end{code}
 138
 139
 140 \begin{code}
 141 varUnique :: Var -> Unique
 142 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
 143
 144 setVarUnique :: Var -> Unique -> Var
 145 setVarUnique var@(Var {varName = name}) uniq
 146   = var {realUnique = getKey uniq,
 147          varName = setNameUnique name uniq}
 148
 149 setVarName :: Var -> Name -> Var
 150 setVarName var new_name
 151   = var { realUnique = getKey (getUnique new_name), varName = new_name }
 152
 153 setVarOcc :: Var -> OccName -> Var
 154 setVarOcc var new_occ
 155   = var { varName = setNameOcc (varName var) new_occ }
 156
 157 setVarType :: Var -> Type -> Var
 158 setVarType var ty = var {varType = ty}
 159 \end{code}
 160
 161
 162 %************************************************************************
 163 %*                                                                      *
 164 \subsection{Type variables}
 165 %*                                                                      *
 166 %************************************************************************
 167
 168 \begin{code}
 169 type TyVar = Var
 170 \end{code}
 171
 172 \begin{code}
 173 tyVarName = varName
 174 tyVarKind = varType
 175
 176 setTyVarUnique = setVarUnique
 177 setTyVarName   = setVarName
 178 \end{code}
 179
 180 \begin{code}
 181 mkTyVar :: Name -> Kind -> TyVar
 182 mkTyVar name kind = Var { varName    = name
 183                         , realUnique = getKey (nameUnique name)
 184                         , varType    = kind
 185                         , varDetails = TyVar
 186                         , varInfo    = pprPanic "mkTyVar" (ppr name)
 187                         }
 188
 189 mkSysTyVar :: Unique -> Kind -> TyVar
 190 mkSysTyVar uniq kind = Var { varName    = name
 191                            , realUnique = getKey uniq
 192                            , varType    = kind
 193                            , varDetails = TyVar
 194                            , varInfo    = pprPanic "mkSysTyVar" (ppr name)
 195                            }
 196                      where
 197                        name = mkSysLocalName uniq SLIT("t")
 198
 199 newMutTyVar :: Name -> Kind -> IO TyVar
 200 newMutTyVar name kind = newTyVar name kind False
 201
 202 newSigTyVar :: Name -> Kind -> IO TyVar
 203 -- Type variables from type signatures are still mutable, because
 204 -- they may get unified with type variables from other signatures
 205 -- But they do contain a flag to distinguish them, so we can tell if
 206 -- we unify them with a non-type-variable.
 207 newSigTyVar name kind = newTyVar name kind True
 208
 209 newTyVar name kind is_sig
 210  = do loc <- newIORef Nothing
 211       return (Var { varName    = name
 212                   , realUnique = getKey (nameUnique name)
 213                   , varType    = kind
 214                   , varDetails = MutTyVar loc is_sig
 215                   , varInfo    = pprPanic "newMutTyVar" (ppr name)
 216                   })
 217
 218 readMutTyVar :: TyVar -> IO (Maybe Type)
 219 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 220
 221 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 222 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 223
 224 makeTyVarImmutable :: TyVar -> TyVar
 225 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 226 \end{code}
 227
 228
 229 %************************************************************************
 230 %*                                                                      *
 231 \subsection{Id Construction}
 232 %*                                                                      *
 233 %************************************************************************
 234
 235 Most Id-related functions are in Id.lhs and MkId.lhs
 236
 237 \begin{code}
 238 type Id     = Var
 239 type DictId = Id
 240 \end{code}
 241
 242 \begin{code}
 243 idName    = varName
 244 idType    = varType
 245 idUnique  = varUnique
 246 idInfo    = varInfo
 247
 248 setIdUnique :: Id -> Unique -> Id
 249 setIdUnique = setVarUnique
 250
 251 setIdName :: Id -> Name -> Id
 252 setIdName = setVarName
 253
 254 setIdNoDiscard :: Id -> Id
 255 setIdNoDiscard id
 256   = WARN( not (isLocalId id), ppr id )
 257     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