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   * 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 setIdNoDiscard :: Id -> Id
 257 setIdNoDiscard id
 258   = WARN( not (isLocalId id), ppr id )
 259     id { varDetails = LocalId Exported }
 260
 261 zapSpecPragmaId :: Id -> Id
 262 zapSpecPragmaId id
 263   = case varDetails id of
 264         LocalId SpecPragma -> id { varDetails = LocalId NotExported }
 265         other              -> id
 266
 267 lazySetIdInfo :: Id -> IdInfo -> Id
 268 lazySetIdInfo var info = var {varInfo = info}
 269
 270 setIdInfo :: Id -> IdInfo -> Id
 271 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 272         -- Try to avoid spack leaks by seq'ing
 273
 274 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 275 modifyIdInfo fn var@(Var {varInfo = info})
 276   = seqIdInfo new_info `seq` var {varInfo = new_info}
 277   where
 278     new_info = fn info
 279
 280 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 281 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 282 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 283                                                         Nothing       -> var
 284                                                         Just new_info -> var {varInfo = new_info}
 285 \end{code}
 286
 287 %************************************************************************
 288 %*                                                                      *
 289 \subsection{Predicates over variables
 290 %*                                                                      *
 291 %************************************************************************
 292
 293 \begin{code}
 294 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
 295 mkId name ty details info
 296   = Var { varName    = name,
 297           realUnique = getKey (nameUnique name),        -- Cache the unique
 298           varType    = ty,
 299           varDetails = details,
 300           varInfo    = info }
 301
 302 mkLocalId :: Name -> Type -> IdInfo -> Id
 303 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
 304
 305 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
 306 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
 307
 308 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
 309 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
 310 \end{code}
 311
 312 \begin{code}
 313 isTyVar, isMutTyVar, isSigTyVar          :: Var -> Bool
 314 isId, isLocalVar, isLocalId              :: Var -> Bool
 315 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
 316 mustHaveLocalBinding                     :: Var -> Bool
 317
 318 isTyVar var = case varDetails var of
 319                 TyVar        -> True
 320                 MutTyVar _ _ -> True
 321                 other        -> False
 322
 323 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 324 isMutTyVar other                             = False
 325
 326 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
 327 isSigTyVar other                                  = False
 328
 329 isId var = case varDetails var of
 330                 LocalId _  -> True
 331                 GlobalId _ -> True
 332                 other      -> False
 333
 334 isLocalId var = case varDetails var of
 335                   LocalId _  -> True
 336                   other      -> False
 337
 338 -- isLocalVar returns True for type variables as well as local Ids
 339 -- These are the variables that we need to pay attention to when finding free
 340 -- variables, or doing dependency analysis.
 341 isLocalVar var = case varDetails var of
 342                     LocalId _    -> True
 343                     TyVar        -> True
 344                     MutTyVar _ _ -> True
 345                     other        -> False
 346
 347 -- mustHaveLocalBinding returns True of Ids and TyVars
 348 -- that must have a binding in this module.  The converse
 349 -- is not quite right: there are some GlobalIds that must have
 350 -- bindings, such as record selectors.  But that doesn't matter,
 351 -- because it's only used for assertions
 352 mustHaveLocalBinding var = isLocalVar var
 353
 354 isGlobalId var = case varDetails var of
 355                    GlobalId _ -> True
 356                    other      -> False
 357
 358 -- isExportedId means "don't throw this away"
 359 isExportedId var = case varDetails var of
 360                         LocalId Exported   -> True
 361                         LocalId SpecPragma -> True
 362                         GlobalId _         -> True
 363                         other              -> False
 364
 365 isSpecPragmaId var = case varDetails var of
 366                         LocalId SpecPragma -> True
 367                         other              -> False
 368 \end{code}
 369
 370 \begin{code}
 371 globalIdDetails :: Var -> GlobalIdDetails
 372 -- Works OK on local Ids too, returning notGlobalId
 373 globalIdDetails var = case varDetails var of
 374                           GlobalId details -> details
 375                           other            -> notGlobalId
 376 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
 377 setGlobalIdDetails id details = id { varDetails = GlobalId details }
 378 \end{code}
 379