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