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, IdOrTyVar,         -- Abstract
   9         VarDetails(..),         -- Concrete
  10         varName, varUnique, varDetails, varInfo, varType,
  11         setVarName, setVarUnique, setVarType,  setVarOcc,
  12
  13
  14         -- TyVars
  15         TyVar,
  16         tyVarName, tyVarKind,
  17         setTyVarName, setTyVarUnique,
  18         mkTyVar, mkSysTyVar, isTyVar,
  19         newMutTyVar, readMutTyVar, writeMutTyVar, isMutTyVar, makeTyVarImmutable,
  20
  21         -- Ids
  22         Id, DictId,
  23         idDetails, idName, idType, idUnique, idInfo, modifyIdInfo,
  24         setIdName, setIdUnique, setIdInfo,
  25         mkId, isId, externallyVisibleId
  26     ) where
  27
  28 #include "HsVersions.h"
  29
  30 import {-# SOURCE #-}   Type( Type, Kind )
  31 import {-# SOURCE #-}   IdInfo( IdInfo )
  32 import {-# SOURCE #-}   Const( Con )
  33
  34 import FieldLabel       ( FieldLabel )
  35 import Unique           ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
  36 import Name             ( Name, OccName, NamedThing(..),
  37                           setNameUnique, setNameOcc, nameUnique,
  38                           mkSysLocalName, isExternallyVisibleName
  39                         )
  40 import BasicTypes       ( Unused )
  41 import Outputable
  42
  43 import IOExts           ( IORef, newIORef, readIORef, writeIORef )
  44 \end{code}
  45
  46
  47
  48 %************************************************************************
  49 %*                                                                      *
  50 \subsection{The main data type declarations}
  51 %*                                                                      *
  52 %************************************************************************
  53
  54
  55 Every @Var@ has a @Unique@, to uniquify it and for fast comparison, a
  56 @Type@, and an @IdInfo@ (non-essential info about it, e.g.,
  57 strictness).  The essential info about different kinds of @Vars@ is
  58 in its @VarDetails@.
  59
  60 \begin{code}
  61 type IdOrTyVar = Var
  62
  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   = VanillaId                           -- Most Ids are like this
  76   | ConstantId Con                      -- The Id for a constant (data constructor or primop)
  77   | RecordSelId FieldLabel              -- The Id for a record selector
  78   | TyVar
  79   | MutTyVar (IORef (Maybe Type))       -- Used during unification
  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 uniq = var {realUnique = getKey uniq,
 118                              varName = setNameUnique (varName var) uniq}
 119
 120 setVarName :: Var -> Name -> Var
 121 setVarName var new_name
 122   = var { realUnique = getKey (getUnique new_name), varName = new_name }
 123
 124 setVarOcc :: Var -> OccName -> Var
 125 setVarOcc var new_occ
 126   = var { varName = setNameOcc (varName var) new_occ }
 127
 128 setVarType :: Var -> Type -> Var
 129 setVarType var ty = var {varType = ty}
 130 \end{code}
 131
 132
 133 %************************************************************************
 134 %*                                                                      *
 135 \subsection{Type variables}
 136 %*                                                                      *
 137 %************************************************************************
 138
 139 \begin{code}
 140 type TyVar = Var
 141 \end{code}
 142
 143 \begin{code}
 144 tyVarName = varName
 145 tyVarKind = varType
 146
 147 setTyVarUnique = setVarUnique
 148 setTyVarName   = setVarName
 149 \end{code}
 150
 151 \begin{code}
 152 mkTyVar :: Name -> Kind -> TyVar
 153 mkTyVar name kind = Var { varName    = name
 154                         , realUnique = getKey (nameUnique name)
 155                         , varType    = kind
 156                         , varDetails = TyVar
 157 #ifdef DEBUG
 158                         , varInfo = pprPanic "mkTyVar" (ppr name)
 159 #endif
 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 #ifdef DEBUG
 168                            , varInfo = pprPanic "mkSysTyVar" (ppr name)
 169 #endif
 170                            }
 171                      where
 172                        name = mkSysLocalName uniq SLIT("t")
 173
 174 newMutTyVar :: Name -> Kind -> IO TyVar
 175 newMutTyVar name kind =
 176   do loc <- newIORef Nothing
 177      return (Var { varName = name,
 178                    realUnique = getKey (nameUnique name),
 179                    varType = kind,
 180                    varDetails = MutTyVar loc })
 181
 182 readMutTyVar :: TyVar -> IO (Maybe Type)
 183 readMutTyVar (Var {varDetails = MutTyVar loc}) = readIORef loc
 184
 185 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 186 writeMutTyVar (Var {varDetails = MutTyVar loc}) val = writeIORef loc val
 187
 188 makeTyVarImmutable :: TyVar -> TyVar
 189 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 190 \end{code}
 191
 192 \begin{code}
 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 \end{code}
 203
 204
 205 %************************************************************************
 206 %*                                                                      *
 207 \subsection{Id Construction}
 208 %*                                                                      *
 209 %************************************************************************
 210
 211         Most Id-related functions are in Id.lhs and MkId.lhs
 212
 213 \begin{code}
 214 type Id     = Var
 215 type DictId = Id
 216 \end{code}
 217
 218 \begin{code}
 219 idName    = varName
 220 idType    = varType
 221 idUnique  = varUnique
 222 idInfo    = varInfo
 223 idDetails = varDetails
 224
 225 setIdUnique :: Id -> Unique -> Id
 226 setIdUnique = setVarUnique
 227
 228 setIdName :: Id -> Name -> Id
 229 setIdName = setVarName
 230
 231 setIdInfo :: Id -> IdInfo -> Id
 232 setIdInfo var info = var {varInfo = info}
 233
 234 modifyIdInfo :: Id -> (IdInfo -> IdInfo) -> Id
 235 modifyIdInfo var@(Var {varInfo = info}) fn = var {varInfo = fn info}
 236 \end{code}
 237
 238 \begin{code}
 239 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
 240 mkId name ty details info
 241   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 242          varDetails = details, varInfo = info}
 243 \end{code}
 244
 245 \begin{code}
 246 isId :: Var -> Bool
 247 isId (Var {varDetails = details}) = case details of
 248                                         VanillaId     -> True
 249                                         ConstantId _  -> True
 250                                         RecordSelId _ -> True
 251                                         other         -> False
 252 \end{code}
 253
 254 @externallyVisibleId@: is it true that another module might be
 255 able to ``see'' this Id in a code generation sense. That
 256 is, another .o file might refer to this Id.
 257
 258 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 259 local-ness precisely so that the test here would be easy
 260
 261 This defn appears here (rather than, say, in Id.lhs) because
 262 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 263
 264 \end{code}
 265 \begin{code}
 266 externallyVisibleId :: Id -> Bool
 267 externallyVisibleId var = isExternallyVisibleName (varName var)
 268 \end{code}