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