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, readMutTyVar, writeMutTyVar, 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                           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              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 = mkSysLocalName uniq FSLIT("t")
 199
 200 newMutTyVar :: Name -> Kind -> TyVarDetails -> IO TyVar
 201 newMutTyVar name kind details
 202   = do loc <- newIORef Nothing
 203        return (Var { varName    = name
 204                    , realUnique = getKey (nameUnique name)
 205                    , varType    = kind
 206                    , varDetails = MutTyVar loc details
 207                    , varInfo    = pprPanic "newMutTyVar" (ppr name)
 208                    })
 209
 210 readMutTyVar :: TyVar -> IO (Maybe Type)
 211 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 212
 213 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 214 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 215
 216 makeTyVarImmutable :: TyVar -> TyVar
 217 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 218
 219 mutTyVarDetails :: TyVar -> TyVarDetails
 220 mutTyVarDetails (Var {varDetails = MutTyVar _ details}) = details
 221 \end{code}
 222
 223
 224 %************************************************************************
 225 %*                                                                      *
 226 \subsection{Id Construction}
 227 %*                                                                      *
 228 %************************************************************************
 229
 230 Most Id-related functions are in Id.lhs and MkId.lhs
 231
 232 \begin{code}
 233 type Id     = Var
 234 type DictId = Id
 235 \end{code}
 236
 237 \begin{code}
 238 idName    = varName
 239 idType    = varType
 240 idUnique  = varUnique
 241 idInfo    = varInfo
 242
 243 setIdUnique :: Id -> Unique -> Id
 244 setIdUnique = setVarUnique
 245
 246 setIdName :: Id -> Name -> Id
 247 setIdName = setVarName
 248
 249 setIdLocalExported :: Id -> Id
 250 setIdLocalExported id = id { varDetails = LocalId Exported }
 251
 252 zapSpecPragmaId :: Id -> Id
 253 zapSpecPragmaId id
 254   = case varDetails id of
 255         LocalId SpecPragma -> id { varDetails = LocalId NotExported }
 256         other              -> id
 257
 258 lazySetIdInfo :: Id -> IdInfo -> Id
 259 lazySetIdInfo var info = var {varInfo = info}
 260
 261 setIdInfo :: Id -> IdInfo -> Id
 262 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 263         -- Try to avoid spack leaks by seq'ing
 264
 265 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 266 modifyIdInfo fn var@(Var {varInfo = info})
 267   = seqIdInfo new_info `seq` var {varInfo = new_info}
 268   where
 269     new_info = fn info
 270
 271 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 272 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 273 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 274                                                         Nothing       -> var
 275                                                         Just new_info -> var {varInfo = new_info}
 276 \end{code}
 277
 278 %************************************************************************
 279 %*                                                                      *
 280 \subsection{Predicates over variables
 281 %*                                                                      *
 282 %************************************************************************
 283
 284 \begin{code}
 285 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
 286 mkId name ty details info
 287   = Var { varName    = name,
 288           realUnique = getKey (nameUnique name),        -- Cache the unique
 289           varType    = ty,
 290           varDetails = details,
 291           varInfo    = info }
 292
 293 mkLocalId :: Name -> Type -> IdInfo -> Id
 294 mkLocalId name ty info = mkId name ty (LocalId NotExported) info
 295
 296 mkSpecPragmaId :: Name -> Type -> IdInfo -> Id
 297 mkSpecPragmaId name ty info = mkId name ty (LocalId SpecPragma) info
 298
 299 mkGlobalId :: GlobalIdDetails -> Name -> Type -> IdInfo -> Id
 300 mkGlobalId details name ty info = mkId name ty (GlobalId details) info
 301 \end{code}
 302
 303 \begin{code}
 304 isTyVar, isMutTyVar                      :: Var -> Bool
 305 isId, isLocalVar, isLocalId              :: Var -> Bool
 306 isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
 307 mustHaveLocalBinding                     :: Var -> Bool
 308
 309 isTyVar var = case varDetails var of
 310                 TyVar        -> True
 311                 MutTyVar _ _ -> True
 312                 other        -> False
 313
 314 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 315 isMutTyVar other                             = False
 316
 317
 318 isId var = case varDetails var of
 319                 LocalId _  -> True
 320                 GlobalId _ -> True
 321                 other      -> False
 322
 323 isLocalId var = case varDetails var of
 324                   LocalId _  -> True
 325                   other      -> False
 326
 327 -- isLocalVar returns True for type variables as well as local Ids
 328 -- These are the variables that we need to pay attention to when finding free
 329 -- variables, or doing dependency analysis.
 330 isLocalVar var = case varDetails var of
 331                     LocalId _    -> True
 332                     TyVar        -> True
 333                     MutTyVar _ _ -> True
 334                     other        -> False
 335
 336 -- mustHaveLocalBinding returns True of Ids and TyVars
 337 -- that must have a binding in this module.  The converse
 338 -- is not quite right: there are some GlobalIds that must have
 339 -- bindings, such as record selectors.  But that doesn't matter,
 340 -- because it's only used for assertions
 341 mustHaveLocalBinding var = isLocalVar var
 342
 343 isGlobalId var = case varDetails var of
 344                    GlobalId _ -> True
 345                    other      -> False
 346
 347 -- isExportedId means "don't throw this away"
 348 isExportedId var = case varDetails var of
 349                         LocalId Exported   -> True
 350                         LocalId SpecPragma -> True
 351                         GlobalId _         -> True
 352                         other              -> False
 353
 354 isSpecPragmaId var = case varDetails var of
 355                         LocalId SpecPragma -> True
 356                         other              -> False
 357 \end{code}
 358
 359 \begin{code}
 360 globalIdDetails :: Var -> GlobalIdDetails
 361 -- Works OK on local Ids too, returning notGlobalId
 362 globalIdDetails var = case varDetails var of
 363                           GlobalId details -> details
 364                           other            -> notGlobalId
 365 setGlobalIdDetails :: Id -> GlobalIdDetails -> Id
 366 setGlobalIdDetails id details = id { varDetails = GlobalId details }
 367 \end{code}
 368