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, 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 FastTypes
  43 import Outputable
  44
  45 import IOExts           ( IORef, newIORef, readIORef, writeIORef )
  46 \end{code}
  47
  48
  49 %************************************************************************
  50 %*                                                                      *
  51 \subsection{The main data type declarations}
  52 %*                                                                      *
  53 %************************************************************************
  54
  55
  56 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
  57 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
  58 strictness).  The essential info about different kinds of @Vars@ is
  59 in its @VarDetails@.
  60
  61 \begin{code}
  62 data Var
  63   = Var {
  64         varName    :: Name,
  65         realUnique :: FastInt,          -- Key for fast comparison
  66                                         -- Identical to the Unique in the name,
  67                                         -- cached here for speed
  68         varType    :: Type,
  69         varDetails :: VarDetails,
  70         varInfo    :: IdInfo            -- Only used for Ids at the moment
  71     }
  72
  73 data VarDetails
  74   = AnId
  75   | TyVar
  76   | MutTyVar (IORef (Maybe Type))       -- Used during unification;
  77              Bool                       -- True <=> this is a type signature variable, which
  78                                         --          should not be unified with a non-tyvar type
  79   | UVar                                -- Usage variable
  80
  81 -- For a long time I tried to keep mutable Vars statically type-distinct
  82 -- from immutable Vars, but I've finally given up.   It's just too painful.
  83 -- After type checking there are no MutTyVars left, but there's no static check
  84 -- of that fact.
  85 \end{code}
  86
  87 \begin{code}
  88 instance Outputable Var where
  89   ppr var = ppr (varName var)
  90
  91 instance Show Var where
  92   showsPrec p var = showsPrecSDoc p (ppr var)
  93
  94 instance NamedThing Var where
  95   getName = varName
  96
  97 instance Uniquable Var where
  98   getUnique = varUnique
  99
 100 instance Eq Var where
 101     a == b = realUnique a ==# realUnique b
 102
 103 instance Ord Var where
 104     a <= b = realUnique a <=# realUnique b
 105     a <  b = realUnique a <#  realUnique b
 106     a >= b = realUnique a >=# realUnique b
 107     a >  b = realUnique a >#  realUnique b
 108     a `compare` b = varUnique a `compare` varUnique b
 109 \end{code}
 110
 111
 112 \begin{code}
 113 varUnique :: Var -> Unique
 114 varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
 115
 116 setVarUnique :: Var -> Unique -> Var
 117 setVarUnique var@(Var {varName = name}) uniq
 118   = var {realUnique = getKey uniq,
 119          varName = setNameUnique name uniq}
 120
 121 setVarName :: Var -> Name -> Var
 122 setVarName var new_name
 123   = var { realUnique = getKey (getUnique new_name), varName = new_name }
 124
 125 setVarOcc :: Var -> OccName -> Var
 126 setVarOcc var new_occ
 127   = var { varName = setNameOcc (varName var) new_occ }
 128
 129 setVarType :: Var -> Type -> Var
 130 setVarType var ty = var {varType = ty}
 131 \end{code}
 132
 133
 134 %************************************************************************
 135 %*                                                                      *
 136 \subsection{Type variables}
 137 %*                                                                      *
 138 %************************************************************************
 139
 140 \begin{code}
 141 type TyVar = Var
 142 \end{code}
 143
 144 \begin{code}
 145 tyVarName = varName
 146 tyVarKind = varType
 147
 148 setTyVarUnique = setVarUnique
 149 setTyVarName   = setVarName
 150 \end{code}
 151
 152 \begin{code}
 153 mkTyVar :: Name -> Kind -> TyVar
 154 mkTyVar name kind = Var { varName    = name
 155                         , realUnique = getKey (nameUnique name)
 156                         , varType    = kind
 157                         , varDetails = TyVar
 158                         , varInfo    = pprPanic "mkTyVar" (ppr name)
 159                         }
 160
 161 mkSysTyVar :: Unique -> Kind -> TyVar
 162 mkSysTyVar uniq kind = Var { varName    = name
 163                            , realUnique = getKey uniq
 164                            , varType    = kind
 165                            , varDetails = TyVar
 166                            , varInfo    = pprPanic "mkSysTyVar" (ppr name)
 167                            }
 168                      where
 169                        name = mkSysLocalName uniq SLIT("t")
 170
 171 newMutTyVar :: Name -> Kind -> IO TyVar
 172 newMutTyVar name kind = newTyVar name kind False
 173
 174 newSigTyVar :: Name -> Kind -> IO TyVar
 175 -- Type variables from type signatures are still mutable, because
 176 -- they may get unified with type variables from other signatures
 177 -- But they do contain a flag to distinguish them, so we can tell if
 178 -- we unify them with a non-type-variable.
 179 newSigTyVar name kind = newTyVar name kind True
 180
 181 newTyVar name kind is_sig
 182  = do loc <- newIORef Nothing
 183       return (Var { varName    = name
 184                   , realUnique = getKey (nameUnique name)
 185                   , varType    = kind
 186                   , varDetails = MutTyVar loc is_sig
 187                   , varInfo    = pprPanic "newMutTyVar" (ppr name)
 188                   })
 189
 190 readMutTyVar :: TyVar -> IO (Maybe Type)
 191 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 192
 193 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 194 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 195
 196 makeTyVarImmutable :: TyVar -> TyVar
 197 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 198
 199 isTyVar :: Var -> Bool
 200 isTyVar (Var {varDetails = details}) = case details of
 201                                         TyVar        -> True
 202                                         MutTyVar _ _ -> True
 203                                         other        -> False
 204
 205 isMutTyVar :: Var -> Bool
 206 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 207 isMutTyVar other                             = False
 208
 209 isSigTyVar :: Var -> Bool
 210 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
 211 isSigTyVar other                                  = False
 212 \end{code}
 213
 214
 215 %************************************************************************
 216 %*                                                                      *
 217 \subsection{Usage variables}
 218 %*                                                                      *
 219 %************************************************************************
 220
 221 \begin{code}
 222 type UVar = Var
 223 \end{code}
 224
 225 \begin{code}
 226 mkUVar :: Unique -> UVar
 227 mkUVar unique = Var { varName    = name
 228                     , realUnique = getKey unique
 229                     , varDetails = UVar
 230                     , varType    = pprPanic "mkUVar (varType)" (ppr name)
 231                     , varInfo    = pprPanic "mkUVar (varInfo)" (ppr name)
 232                     }
 233               where name = mkSysLocalName unique SLIT("u")
 234
 235 mkNamedUVar :: Name -> UVar
 236 mkNamedUVar name = Var { varName    = name
 237                        , realUnique = getKey (nameUnique name)
 238                        , varDetails = UVar
 239                        , varType    = pprPanic "mkNamedUVar (varType)" (ppr name)
 240                        , varInfo    = pprPanic "mkNamedUVar (varInfo)" (ppr name)
 241                        }
 242 \end{code}
 243
 244 \begin{code}
 245 isUVar :: Var -> Bool
 246 isUVar (Var {varDetails = details}) = case details of
 247                                         UVar       -> True
 248                                         other      -> False
 249 \end{code}
 250
 251
 252 %************************************************************************
 253 %*                                                                      *
 254 \subsection{Id Construction}
 255 %*                                                                      *
 256 %************************************************************************
 257
 258 Most Id-related functions are in Id.lhs and MkId.lhs
 259
 260 \begin{code}
 261 type Id     = Var
 262 type DictId = Id
 263 \end{code}
 264
 265 \begin{code}
 266 idName    = varName
 267 idType    = varType
 268 idUnique  = varUnique
 269 idInfo    = varInfo
 270
 271 setIdUnique :: Id -> Unique -> Id
 272 setIdUnique = setVarUnique
 273
 274 setIdName :: Id -> Name -> Id
 275 setIdName = setVarName
 276
 277 lazySetIdInfo :: Id -> IdInfo -> Id
 278 lazySetIdInfo var info = var {varInfo = info}
 279
 280 setIdInfo :: Id -> IdInfo -> Id
 281 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 282         -- Try to avoid spack leaks by seq'ing
 283
 284 zapIdInfo :: Id -> Id
 285 zapIdInfo var = var {varInfo = vanillaIdInfo}
 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}