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