ghc/compiler/basicTypes/Var.lhs

   1 s%
   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, lazySetIdInfo,
  30         mkIdVar, isId, externallyVisibleId
  31     ) where
  32
  33 #include "HsVersions.h"
  34
  35 import {-# SOURCE #-}   Type( Type, Kind )
  36 import {-# SOURCE #-}   IdInfo( IdInfo, seqIdInfo )
  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@(Var {varName = name}) uniq
 122   = var {realUnique = getKey uniq,
 123          varName = setNameUnique name uniq}
 124
 125 setVarName :: Var -> Name -> Var
 126 setVarName var new_name
 127   = var { realUnique = getKey (getUnique new_name), varName = new_name }
 128
 129 setVarOcc :: Var -> OccName -> Var
 130 setVarOcc var new_occ
 131   = var { varName = setNameOcc (varName var) new_occ }
 132
 133 setVarType :: Var -> Type -> Var
 134 setVarType var ty = var {varType = ty}
 135 \end{code}
 136
 137
 138 %************************************************************************
 139 %*                                                                      *
 140 \subsection{Type variables}
 141 %*                                                                      *
 142 %************************************************************************
 143
 144 \begin{code}
 145 type TyVar = Var
 146 \end{code}
 147
 148 \begin{code}
 149 tyVarName = varName
 150 tyVarKind = varType
 151
 152 setTyVarUnique = setVarUnique
 153 setTyVarName   = setVarName
 154 \end{code}
 155
 156 \begin{code}
 157 mkTyVar :: Name -> Kind -> TyVar
 158 mkTyVar name kind = Var { varName    = name
 159                         , realUnique = getKey (nameUnique name)
 160                         , varType    = kind
 161                         , varDetails = TyVar
 162 #ifdef DEBUG
 163                         , varInfo = pprPanic "looking at IdInfo of a tyvar" (ppr name)
 164 #endif
 165                         }
 166
 167 mkSysTyVar :: Unique -> Kind -> TyVar
 168 mkSysTyVar uniq kind = Var { varName    = name
 169                            , realUnique = getKey uniq
 170                            , varType    = kind
 171                            , varDetails = TyVar
 172 #ifdef DEBUG
 173                            , varInfo = pprPanic "mkSysTyVar" (ppr name)
 174 #endif
 175                            }
 176                      where
 177                        name = mkSysLocalName uniq SLIT("t")
 178
 179 newMutTyVar :: Name -> Kind -> IO TyVar
 180 newMutTyVar name kind =
 181   do loc <- newIORef Nothing
 182      return (Var { varName = name,
 183                    realUnique = getKey (nameUnique name),
 184                    varType = kind,
 185                    varDetails = MutTyVar loc False})
 186
 187 newSigTyVar :: Name -> Kind -> IO TyVar
 188 newSigTyVar name kind =
 189   do loc <- newIORef Nothing
 190      return (Var { varName = name,
 191                    realUnique = getKey (nameUnique name),
 192                    varType = kind,
 193                    varDetails = MutTyVar loc True})
 194
 195 readMutTyVar :: TyVar -> IO (Maybe Type)
 196 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 197
 198 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 199 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 200
 201 makeTyVarImmutable :: TyVar -> TyVar
 202 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 203
 204 isTyVar :: Var -> Bool
 205 isTyVar (Var {varDetails = details}) = case details of
 206                                         TyVar        -> True
 207                                         MutTyVar _ _ -> True
 208                                         other        -> False
 209
 210 isMutTyVar :: Var -> Bool
 211 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 212 isMutTyVar other                             = False
 213
 214 isSigTyVar :: Var -> Bool
 215 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
 216 isSigTyVar other                                  = False
 217 \end{code}
 218
 219
 220 %************************************************************************
 221 %*                                                                      *
 222 \subsection{Usage variables}
 223 %*                                                                      *
 224 %************************************************************************
 225
 226 \begin{code}
 227 type UVar = Var
 228 \end{code}
 229
 230 \begin{code}
 231 mkUVar :: Unique -> UVar
 232 mkUVar unique = Var { varName    = mkSysLocalName unique SLIT("u"),
 233                       realUnique = getKey unique,
 234                       varDetails = UVar }
 235 \end{code}
 236
 237 \begin{code}
 238 isUVar :: Var -> Bool
 239 isUVar (Var {varDetails = details}) = case details of
 240                                         UVar       -> True
 241                                         other      -> False
 242 \end{code}
 243
 244
 245 %************************************************************************
 246 %*                                                                      *
 247 \subsection{Id Construction}
 248 %*                                                                      *
 249 %************************************************************************
 250
 251 Most Id-related functions are in Id.lhs and MkId.lhs
 252
 253 \begin{code}
 254 type Id     = Var
 255 type DictId = Id
 256 \end{code}
 257
 258 \begin{code}
 259 idName    = varName
 260 idType    = varType
 261 idUnique  = varUnique
 262 idInfo    = varInfo
 263
 264 setIdUnique :: Id -> Unique -> Id
 265 setIdUnique = setVarUnique
 266
 267 setIdName :: Id -> Name -> Id
 268 setIdName = setVarName
 269
 270 lazySetIdInfo :: Id -> IdInfo -> Id
 271 lazySetIdInfo var info = var {varInfo = info}
 272
 273 setIdInfo :: Id -> IdInfo -> Id
 274 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 275         -- Try to avoid spack leaks by seq'ing
 276
 277 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 278 modifyIdInfo fn var@(Var {varInfo = info})
 279   = seqIdInfo new_info `seq` var {varInfo = new_info}
 280   where
 281     new_info = fn info
 282
 283 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 284 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 285 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 286                                                 Nothing       -> var
 287                                                 Just new_info -> var {varInfo = new_info}
 288 \end{code}
 289
 290 \begin{code}
 291 mkIdVar :: Name -> Type -> IdInfo -> Id
 292 mkIdVar name ty info
 293   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 294          varDetails = AnId, varInfo = info}
 295 \end{code}
 296
 297 \begin{code}
 298 isId :: Var -> Bool
 299 isId (Var {varDetails = AnId}) = True
 300 isId other                     = False
 301 \end{code}
 302
 303 @externallyVisibleId@: is it true that another module might be
 304 able to ``see'' this Id in a code generation sense. That
 305 is, another .o file might refer to this Id.
 306
 307 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 308 local-ness precisely so that the test here would be easy
 309
 310 This defn appears here (rather than, say, in Id.lhs) because
 311 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 312
 313 \end{code}
 314 \begin{code}
 315 externallyVisibleId :: Id -> Bool
 316 externallyVisibleId var = isExternallyVisibleName (varName var)
 317 \end{code}