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 -- Type variables from type signatures are still mutable, because
 177 -- they may get unified with type variables from other signatures
 178 -- But they do contain a flag to distinguish them, so we can tell if
 179 -- we unify them with a non-type-variable.
 180 newSigTyVar name kind = newTyVar name kind True
 181
 182 newTyVar name kind is_sig
 183  = do loc <- newIORef Nothing
 184       return (Var { varName    = name
 185                   , realUnique = getKey (nameUnique name)
 186                   , varType    = kind
 187                   , varDetails = MutTyVar loc is_sig
 188                   , varInfo    = pprPanic "newMutTyVar" (ppr name)
 189                   })
 190
 191 readMutTyVar :: TyVar -> IO (Maybe Type)
 192 readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
 193
 194 writeMutTyVar :: TyVar -> Maybe Type -> IO ()
 195 writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
 196
 197 makeTyVarImmutable :: TyVar -> TyVar
 198 makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
 199
 200 isTyVar :: Var -> Bool
 201 isTyVar (Var {varDetails = details}) = case details of
 202                                         TyVar        -> True
 203                                         MutTyVar _ _ -> True
 204                                         other        -> False
 205
 206 isMutTyVar :: Var -> Bool
 207 isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
 208 isMutTyVar other                             = False
 209
 210 isSigTyVar :: Var -> Bool
 211 isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
 212 isSigTyVar other                                  = False
 213 \end{code}
 214
 215
 216 %************************************************************************
 217 %*                                                                      *
 218 \subsection{Usage variables}
 219 %*                                                                      *
 220 %************************************************************************
 221
 222 \begin{code}
 223 type UVar = Var
 224 \end{code}
 225
 226 \begin{code}
 227 mkUVar :: Unique -> UVar
 228 mkUVar unique = Var { varName    = name
 229                     , realUnique = getKey unique
 230                     , varDetails = UVar
 231                     , varType    = pprPanic "mkUVar (varType)" (ppr name)
 232                     , varInfo    = pprPanic "mkUVar (varInfo)" (ppr name)
 233                     }
 234               where name = mkSysLocalName unique SLIT("u")
 235
 236 mkNamedUVar :: Name -> UVar
 237 mkNamedUVar name = Var { varName    = name
 238                        , realUnique = getKey (nameUnique name)
 239                        , varDetails = UVar
 240                        , varType    = pprPanic "mkNamedUVar (varType)" (ppr name)
 241                        , varInfo    = pprPanic "mkNamedUVar (varInfo)" (ppr name)
 242                        }
 243 \end{code}
 244
 245 \begin{code}
 246 isUVar :: Var -> Bool
 247 isUVar (Var {varDetails = details}) = case details of
 248                                         UVar       -> True
 249                                         other      -> False
 250 \end{code}
 251
 252
 253 %************************************************************************
 254 %*                                                                      *
 255 \subsection{Id Construction}
 256 %*                                                                      *
 257 %************************************************************************
 258
 259 Most Id-related functions are in Id.lhs and MkId.lhs
 260
 261 \begin{code}
 262 type Id     = Var
 263 type DictId = Id
 264 \end{code}
 265
 266 \begin{code}
 267 idName    = varName
 268 idType    = varType
 269 idUnique  = varUnique
 270 idInfo    = varInfo
 271
 272 setIdUnique :: Id -> Unique -> Id
 273 setIdUnique = setVarUnique
 274
 275 setIdName :: Id -> Name -> Id
 276 setIdName = setVarName
 277
 278 lazySetIdInfo :: Id -> IdInfo -> Id
 279 lazySetIdInfo var info = var {varInfo = info}
 280
 281 setIdInfo :: Id -> IdInfo -> Id
 282 setIdInfo var info = seqIdInfo info `seq` var {varInfo = info}
 283         -- Try to avoid spack leaks by seq'ing
 284
 285 zapIdInfo :: Id -> Id
 286 zapIdInfo var = var {varInfo = vanillaIdInfo}
 287
 288 modifyIdInfo :: (IdInfo -> IdInfo) -> Id -> Id
 289 modifyIdInfo fn var@(Var {varInfo = info})
 290   = seqIdInfo new_info `seq` var {varInfo = new_info}
 291   where
 292     new_info = fn info
 293
 294 -- maybeModifyIdInfo tries to avoid unnecesary thrashing
 295 maybeModifyIdInfo :: (IdInfo -> Maybe IdInfo) -> Id -> Id
 296 maybeModifyIdInfo fn var@(Var {varInfo = info}) = case fn info of
 297                                                 Nothing       -> var
 298                                                 Just new_info -> var {varInfo = new_info}
 299 \end{code}
 300
 301 \begin{code}
 302 mkIdVar :: Name -> Type -> IdInfo -> Id
 303 mkIdVar name ty info
 304   = Var {varName = name, realUnique = getKey (nameUnique name), varType = ty,
 305          varDetails = AnId, varInfo = info}
 306 \end{code}
 307
 308 \begin{code}
 309 isId :: Var -> Bool
 310 isId (Var {varDetails = AnId}) = True
 311 isId other                     = False
 312 \end{code}
 313
 314 @externallyVisibleId@: is it true that another module might be
 315 able to ``see'' this Id in a code generation sense. That
 316 is, another .o file might refer to this Id.
 317
 318 In tidyCorePgm (SimplCore.lhs) we carefully set each top level thing's
 319 local-ness precisely so that the test here would be easy
 320
 321 This defn appears here (rather than, say, in Id.lhs) because
 322 CostCentre.lhs uses it (CostCentre feeds PprType feeds Id.lhs)
 323
 324 \end{code}
 325 \begin{code}
 326 externallyVisibleId :: Id -> Bool
 327 externallyVisibleId var = isExternallyVisibleName (varName var)
 328 \end{code}