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