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