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, IdOrTyVar, VarDetails,             -- Abstract
   9         varName, varUnique, varInfo, varType,
  10         setVarName, setVarUnique, setVarType, setVarOcc,
  11
  12
  13         -- TyVars
  14         TyVar,
  15         tyVarName, tyVarKind,
  16         setTyVarName, setTyVarUnique,
  17         mkTyVar, mkSysTyVar, isTyVar, isSigTyVar,
  18         newMutTyVar, newSigTyVar,
  19         readMutTyVar, writeMutTyVar, isMutTyVar, makeTyVarImmutable,
  20
  21         -- UVars
  22         UVar,
  23         isUVar,
  24         mkUVar,
  25
  26         -- Ids
  27         Id, DictId,
  28         idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
  29         setIdName, setIdUnique, setIdInfo,
  30         mkIdVar, isId, externallyVisibleId
  31     ) where
  32
  33 #include "HsVersions.h"
  34
  35 import {-# SOURCE #-}   Type( Type, Kind )
  36 import {-# SOURCE #-}   IdInfo( IdInfo )
  37
  38 import Unique           ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
  39 import Name             ( Name, OccName, NamedThing(..),
  40                           setNameUnique, setNameOcc, nameUnique,
  41                           mkSysLocalName, isExternallyVisibleName
  42                         )
  43 import BasicTypes       ( Unused )
  44 import Outputable
  45
  46 import IOExts           ( IORef, newIORef, readIORef, writeIORef )
  47 \end{code}
  48
  49
  50
  51 %************************************************************************
  52 %*                                                                      *
  53 \subsection{The main data type declarations}
  54 %*                                                                      *
  55 %************************************************************************
  56
  57
  58 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
  59 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
  60 strictness).  The essential info about different kinds of @Vars@ is
  61 in its @VarDetails@.
  62
  63 \begin{code}
  64 type IdOrTyVar = Var
  65
  66 data Var
  67   = Var {
  68         varName    :: Name,
  69         realUnique :: Int#,             -- Key for fast comparison
  70                                         -- Identical to the Unique in the name,
  71                                         -- cached here for speed
  72         varType    :: Type,
  73         varDetails :: VarDetails,
  74         varInfo    :: IdInfo            -- Only used for Ids at the moment
  75     }
  76
  77 data VarDetails
  78   = AnId
  79   | TyVar
  80   | MutTyVar (IORef (Maybe Type))       -- Used during unification;
  81              Bool                       -- True <=> this is a type signature variable, which
  82                                         --          should not be unified with a non-tyvar type
  83   | UVar                                -- Usage variable
  84
  85 -- For a long time I tried to keep mutable Vars statically type-distinct
  86 -- from immutable Vars, but I've finally given up.   It's just too painful.
  87 -- After type checking there are no MutTyVars left, but there's no static check
  88 -- of that fact.
  89 \end{code}
  90
  91 \begin{code}
  92 instance Outputable Var where
  93   ppr var = ppr (varName var)
  94
  95 instance Show Var where
  96   showsPrec p var = showsPrecSDoc p (ppr var)
  97
  98 instance NamedThing Var where
  99   getName = varName
 100
 101 instance Uniquable Var where
 102   getUnique = varUnique
 103
 104 instance Eq Var where
 105     a == b = realUnique a ==# realUnique b
 106
 107 instance Ord Var where
 108     a <= b = realUnique a <=# realUnique b
 109     a <  b = realUnique a <#  realUnique b
 110     a >= b = realUnique a >=# realUnique b
 111     a >  b = realUnique a >#  realUnique b
 112     a `compare` b = varUnique a `compare` varUnique b
 113 \end{code}
 114
 115
 116 \begin{code}
 117 varUnique :: Var -> Unique
 118 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
 119
 120 setVarUnique :: Var -> Unique -> Var
 121 setVarUnique var uniq = var {realUnique = getKey uniq,
 122                              varName = setNameUnique (varName var) uniq}
 123
 124 setVarName :: Var -> Name -> Var
 125 setVarName var new_name
 126   = var { realUnique = getKey (getUnique new_name), varName = new_name }
 127
 128 setVarOcc :: Var -> OccName -> Var
 129 setVarOcc var new_occ
 130   = var { varName = setNameOcc (varName var) new_occ }
 131
 132 setVarType :: Var -> Type -> Var
 133 setVarType var ty = var {varType = ty}
 134 \end{code}
 135
 136
 137 %************************************************************************
 138 %*                                                                      *
 139 \subsection{Type variables}
 140 %*                                                                      *
 141 %************************************************************************
 142
 143 \begin{code}
 144 type TyVar = Var
 145 \end{code}
 146
 147 \begin{code}
 148 tyVarName = varName
 149 tyVarKind = varType
 150
 151 setTyVarUnique = setVarUnique
 152 setTyVarName   = setVarName
 153 \end{code}
 154
 155 \begin{code}
 156 mkTyVar :: Name -> Kind -> TyVar
 157 mkTyVar name kind = Var { varName    = name
 158                         , realUnique = getKey (nameUnique name)
 159                         , varType    = kind
 160                         , varDetails = TyVar
 161 #ifdef DEBUG
 162                         , varInfo = pprPanic "looking at IdInfo of a tyvar" (ppr name)
 163 #endif
 164                         }
 165
 166 mkSysTyVar :: Unique -> Kind -> TyVar
 167 mkSysTyVar uniq kind = Var { varName    = name
 168                            , realUnique = getKey uniq
 169                            , varType    = kind
 170                            , varDetails = TyVar
 171 #ifdef DEBUG
 172                            , varInfo = pprPanic "mkSysTyVar" (ppr name)
 173 #endif
 174                            }
 175                      where
 176                        name = mkSysLocalName uniq SLIT("t")
 177
 178 newMutTyVar :: Name -> Kind -> IO TyVar
 179 newMutTyVar name kind =
 180   do loc <- newIORef Nothing
 181      return (Var { varName = name,
 182                    realUnique = getKey (nameUnique name),
 183                    varType = kind,
 184                    varDetails = MutTyVar loc False})
 185
 186 newSigTyVar :: Name -> Kind -> IO TyVar
 187 newSigTyVar name kind =
 188   do loc <- newIORef Nothing
 189      return (Var { varName = name,
 190                    realUnique = getKey (nameUnique name),
 191                    varType = kind,
 192                    varDetails = MutTyVar loc True})
 193
 194 readMutTyVar :: TyVar -> IO (Maybe Type)
 195 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 196
 197 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 198 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 199
 200 makeTyVarImmutable :: TyVar -> TyVar
 201 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 202
 203 isTyVar :: Var -> Bool
 204 isTyVar (Var {varDetails = details}) = case details of
 205                                         TyVar        -> True
 206                                         MutTyVar _ _ -> True
 207                                         other        -> False
 208
 209 isMutTyVar :: Var -> Bool
 210 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 211 isMutTyVar other                             = False
 212
 213 isSigTyVar :: Var -> Bool
 214 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
 215 isSigTyVar other                                  = False
 216 \end{code}
 217
 218
 219 %************************************************************************
 220 %*                                                                      *
 221 \subsection{Usage variables}
 222 %*                                                                      *
 223 %************************************************************************
 224
 225 \begin{code}
 226 type UVar = Var
 227 \end{code}
 228
 229 \begin{code}
 230 mkUVar :: Unique -> UVar
 231 mkUVar unique = Var { varName    = mkSysLocalName unique SLIT("u"),
 232                       realUnique = getKey unique,
 233                       varDetails = UVar }
 234 \end{code}
 235
 236 \begin{code}
 237 isUVar :: Var -> Bool
 238 isUVar (Var {varDetails = details}) = case details of
 239                                         UVar       -> True
 240                                         other      -> False
 241 \end{code}
 242
 243
 244 %************************************************************************
 245 %*                                                                      *
 246 \subsection{Id Construction}
 247 %*                                                                      *
 248 %************************************************************************
 249
 250 Most Id-related functions are in Id.lhs and MkId.lhs
 251
 252 \begin{code}
 253 type Id     = Var
 254 type DictId = Id
 255 \end{code}
 256
 257 \begin{code}
 258 idName    = varName
 259 idType    = varType
 260 idUnique  = varUnique
 261 idInfo    = varInfo
 262
 263 setIdUnique :: Id -> Unique -> Id
 264 setIdUnique = setVarUnique
 265
 266 setIdName :: Id -> Name -> Id
 267 setIdName = setVarName
 268
 269 setIdInfo :: Id -> IdInfo -> Id
 270 setIdInfo var info = var {varInfo = info}
 271
 272 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 273 modifyIdInfo fn var@(Var {varInfo = info}) = var {varInfo = fn info}
 274
 275 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 276 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 277 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 278                                                 Nothing       -> var
 279                                                 Just new_info -> var {varInfo = new_info}
 280 \end{code}
 281
 282 \begin{code}
 283 mkIdVar :: Name -> Type -> IdInfo -> Id
 284 mkIdVar name ty info
 285   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 286          varDetails = AnId, varInfo = info}
 287 \end{code}
 288
 289 \begin{code}
 290 isId :: Var -> Bool
 291 isId (Var {varDetails = AnId}) = True
 292 isId other                     = False
 293 \end{code}
 294
 295 @externallyVisibleId@: is it true that another module might be
 296 able to ``see'' this Id in a code generation sense. That
 297 is, another .o file might refer to this Id.
 298
 299 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 300 local-ness precisely so that the test here would be easy
 301
 302 This defn appears here (rather than, say, in Id.lhs) because
 303 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 304
 305 \end{code}
 306 \begin{code}
 307 externallyVisibleId :: Id -> Bool
 308 externallyVisibleId var = isExternallyVisibleName (varName var)
 309 \end{code}