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, realUnique = getKey (nameUnique name),
 154                           varType = kind, varDetails = TyVar }
 155
 156 mkSysTyVar :: Unique -> Kind -> TyVar
 157 mkSysTyVar uniq kind = Var { varName = name, realUnique = getKey uniq,
 158                              varType = kind, varDetails = TyVar }
 159                      where
 160                        name = mkSysLocalName uniq SLIT("t")
 161
 162 newMutTyVar :: Name -> Kind -> IO TyVar
 163 newMutTyVar name kind =
 164   do loc <- newIORef Nothing
 165      return (Var { varName = name,
 166                    realUnique = getKey (nameUnique name),
 167                    varType = kind,
 168                    varDetails = MutTyVar loc })
 169
 170 readMutTyVar :: TyVar -> IO (Maybe Type)
 171 readMutTyVar (Var {varDetails = MutTyVar loc}) = readIORef loc
 172
 173 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 174 writeMutTyVar (Var {varDetails = MutTyVar loc}) val = writeIORef loc val
 175
 176 makeTyVarImmutable :: TyVar -> TyVar
 177 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 178 \end{code}
 179
 180 \begin{code}
 181 isTyVar :: Var -> Bool
 182 isTyVar (Var {varDetails = details}) = case details of
 183                                         TyVar      -> True
 184                                         MutTyVar _ -> True
 185                                         other      -> False
 186
 187 isMutTyVar :: Var -> Bool
 188 isMutTyVar (Var {varDetails = MutTyVar _}) = True
 189 isMutTyVar other                               = False
 190 \end{code}
 191
 192
 193 %************************************************************************
 194 %*                                                                      *
 195 \subsection{Id Construction}
 196 %*                                                                      *
 197 %************************************************************************
 198
 199         Most Id-related functions are in Id.lhs and MkId.lhs
 200
 201 \begin{code}
 202 type Id     = Var
 203 type DictId = Id
 204 \end{code}
 205
 206 \begin{code}
 207 idName    = varName
 208 idType    = varType
 209 idUnique  = varUnique
 210 idInfo    = varInfo
 211 idDetails = varDetails
 212
 213 setIdUnique :: Id -> Unique -> Id
 214 setIdUnique = setVarUnique
 215
 216 setIdName :: Id -> Name -> Id
 217 setIdName = setVarName
 218
 219 setIdInfo :: Id -> IdInfo -> Id
 220 setIdInfo var info = var {varInfo = info}
 221
 222 modifyIdInfo :: Id -> (IdInfo -> IdInfo) -> Id
 223 modifyIdInfo var@(Var {varInfo = info}) fn = var {varInfo = fn info}
 224 \end{code}
 225
 226 \begin{code}
 227 mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
 228 mkId name ty details info
 229   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 230          varDetails = details, varInfo = info}
 231 \end{code}
 232
 233 \begin{code}
 234 isId :: Var -> Bool
 235 isId (Var {varDetails = details}) = case details of
 236                                         VanillaId     -> True
 237                                         ConstantId _  -> True
 238                                         RecordSelId _ -> True
 239                                         other         -> False
 240 \end{code}
 241
 242 @externallyVisibleId@: is it true that another module might be
 243 able to ``see'' this Id in a code generation sense. That
 244 is, another .o file might refer to this Id.
 245
 246 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 247 local-ness precisely so that the test here would be easy
 248
 249 This defn appears here (rather than, say, in Id.lhs) because
 250 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 251
 252 \end{code}
 253 \begin{code}
 254 externallyVisibleId :: Id -> Bool
 255 externallyVisibleId var = isExternallyVisibleName (varName var)
 256 \end{code}