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, mkNamedUVar,
  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 #-}   TypeRep( 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
 236 mkNamedUVar :: Name -> UVar
 237 mkNamedUVar name = Var { varName    = name
 238                        , realUnique = getKey (nameUnique name)
 239                        , varDetails = UVar
 240 #ifdef DEBUG
 241                        , varType = pprPanic "looking at Type of a uvar" (ppr name)
 242                        , varInfo = pprPanic "looking at IdInfo of a uvar" (ppr name)
 243 #endif
 244                        }
 245 \end{code}
 246
 247 \begin{code}
 248 isUVar :: Var -> Bool
 249 isUVar (Var {varDetails = details}) = case details of
 250                                         UVar       -> True
 251                                         other      -> False
 252 \end{code}
 253
 254
 255 %************************************************************************
 256 %*                                                                      *
 257 \subsection{Id Construction}
 258 %*                                                                      *
 259 %************************************************************************
 260
 261 Most Id-related functions are in Id.lhs and MkId.lhs
 262
 263 \begin{code}
 264 type Id     = Var
 265 type DictId = Id
 266 \end{code}
 267
 268 \begin{code}
 269 idName    = varName
 270 idType    = varType
 271 idUnique  = varUnique
 272 idInfo    = varInfo
 273
 274 setIdUnique :: Id -> Unique -> Id
 275 setIdUnique = setVarUnique
 276
 277 setIdName :: Id -> Name -> Id
 278 setIdName = setVarName
 279
 280 lazySetIdInfo :: Id -> IdInfo -> Id
 281 lazySetIdInfo var info = var {varInfo = info}
 282
 283 setIdInfo :: Id -> IdInfo -> Id
 284 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 285         -- Try to avoid spack leaks by seq'ing
 286
 287 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 288 modifyIdInfo fn var@(Var {varInfo = info})
 289   = seqIdInfo new_info `seq` var {varInfo = new_info}
 290   where
 291     new_info = fn info
 292
 293 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 294 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 295 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 296                                                 Nothing       -> var
 297                                                 Just new_info -> var {varInfo = new_info}
 298 \end{code}
 299
 300 \begin{code}
 301 mkIdVar :: Name -> Type -> IdInfo -> Id
 302 mkIdVar name ty info
 303   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 304          varDetails = AnId, varInfo = info}
 305 \end{code}
 306
 307 \begin{code}
 308 isId :: Var -> Bool
 309 isId (Var {varDetails = AnId}) = True
 310 isId other                     = False
 311 \end{code}
 312
 313 @externallyVisibleId@: is it true that another module might be
 314 able to ``see'' this Id in a code generation sense. That
 315 is, another .o file might refer to this Id.
 316
 317 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 318 local-ness precisely so that the test here would be easy
 319
 320 This defn appears here (rather than, say, in Id.lhs) because
 321 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 322
 323 \end{code}
 324 \begin{code}
 325 externallyVisibleId :: Id -> Bool
 326 externallyVisibleId var = isExternallyVisibleName (varName var)
 327 \end{code}