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