tyVarName, tyVarKind,
setTyVarName, setTyVarUnique,
mkTyVar, mkSysTyVar,
- newMutTyVar, newSigTyVar,
- readMutTyVar, writeMutTyVar, makeTyVarImmutable,
+ mkMutTyVar, mutTyVarRef, makeTyVarImmutable,
-- Ids
Id, DictId,
idName, idType, idUnique, idInfo, modifyIdInfo, maybeModifyIdInfo,
setIdName, setIdUnique, setIdInfo, lazySetIdInfo,
- setIdNoDiscard, zapSpecPragmaId,
+ setIdLocalExported, zapSpecPragmaId,
globalIdDetails, setGlobalIdDetails,
mkLocalId, mkGlobalId, mkSpecPragmaId,
- isTyVar, isMutTyVar, isSigTyVar,
+ isTyVar, isMutTyVar, mutTyVarDetails,
isId, isLocalVar, isLocalId,
isGlobalId, isExportedId, isSpecPragmaId,
mustHaveLocalBinding
#include "HsVersions.h"
import {-# SOURCE #-} TypeRep( Type, Kind )
+import {-# SOURCE #-} TcType( TyVarDetails )
import {-# SOURCE #-} IdInfo( GlobalIdDetails, notGlobalId,
IdInfo, seqIdInfo )
import Name ( Name, OccName, NamedThing(..),
setNameUnique, setNameOcc, nameUnique,
- mkSysLocalName, isExternallyVisibleName
+ mkSystemTvNameEncoded,
)
-import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey )
+import Unique ( Unique, Uniquable(..), mkUniqueGrimily, getKey# )
import FastTypes
import Outputable
-import IOExts ( IORef, newIORef, readIORef, writeIORef )
+import DATA_IOREF ( IORef )
\end{code}
\begin{code}
data Var
= Var {
- varName :: Name,
+ varName :: !Name,
realUnique :: FastInt, -- Key for fast comparison
-- Identical to the Unique in the name,
-- cached here for speed
data VarDetails
= LocalId -- Used for locally-defined Ids (see NOTE below)
- LocalIdDetails -- True <=> exported; don't discard even if dead
+ LocalIdDetails
| GlobalId -- Used for imported Ids, dict selectors etc
GlobalIdDetails
| TyVar
| MutTyVar (IORef (Maybe Type)) -- Used during unification;
- Bool -- True <=> this is a type signature variable, which
- -- should not be unified with a non-tyvar type
+ TyVarDetails
+ -- TODO: the IORef should be unboxed here, but we don't want to unbox
+ -- the Name above.
- -- For a long time I tried to keep mutable Vars statically type-distinct
- -- from immutable Vars, but I've finally given up. It's just too painful.
- -- After type checking there are no MutTyVars left, but there's no static check
- -- of that fact.
+ -- For a long time I tried to keep mutable Vars statically
+ -- type-distinct from immutable Vars, but I've finally given
+ -- up. It's just too painful. After type checking there are
+ -- no MutTyVars left, but there's no static check of that
+ -- fact.
data LocalIdDetails
= NotExported -- Not exported
A GlobalId is
* always a constant (top-level)
* imported, or data constructor, or primop, or record selector
+ * has a Unique that is globally unique across the whole
+ GHC invocation (a single invocation may compile multiple modules)
A LocalId is
* bound within an expression (lambda, case, local let(rec))
\begin{code}
varUnique :: Var -> Unique
-varUnique (Var {realUnique = uniq}) = mkUniqueGrimily uniq
+varUnique (Var {realUnique = uniq}) = mkUniqueGrimily (iBox uniq)
setVarUnique :: Var -> Unique -> Var
setVarUnique var@(Var {varName = name}) uniq
- = var {realUnique = getKey uniq,
+ = var {realUnique = getKey# uniq,
varName = setNameUnique name uniq}
setVarName :: Var -> Name -> Var
setVarName var new_name
- = var { realUnique = getKey (getUnique new_name), varName = new_name }
+ = var { realUnique = getKey# (getUnique new_name), varName = new_name }
setVarOcc :: Var -> OccName -> Var
setVarOcc var new_occ
\begin{code}
mkTyVar :: Name -> Kind -> TyVar
mkTyVar name kind = Var { varName = name
- , realUnique = getKey (nameUnique name)
+ , realUnique = getKey# (nameUnique name)
, varType = kind
, varDetails = TyVar
, varInfo = pprPanic "mkTyVar" (ppr name)
mkSysTyVar :: Unique -> Kind -> TyVar
mkSysTyVar uniq kind = Var { varName = name
- , realUnique = getKey uniq
+ , realUnique = getKey# uniq
, varType = kind
, varDetails = TyVar
, varInfo = pprPanic "mkSysTyVar" (ppr name)
}
where
- name = mkSysLocalName uniq SLIT("t")
+ name = mkSystemTvNameEncoded uniq FSLIT("t")
-newMutTyVar :: Name -> Kind -> IO TyVar
-newMutTyVar name kind = newTyVar name kind False
+mkMutTyVar :: Name -> Kind -> TyVarDetails -> IORef (Maybe Type) -> TyVar
+mkMutTyVar name kind details ref
+ = Var { varName = name
+ , realUnique = getKey# (nameUnique name)
+ , varType = kind
+ , varDetails = MutTyVar ref details
+ , varInfo = pprPanic "newMutTyVar" (ppr name)
+ }
-newSigTyVar :: Name -> Kind -> IO TyVar
--- Type variables from type signatures are still mutable, because
--- they may get unified with type variables from other signatures
--- But they do contain a flag to distinguish them, so we can tell if
--- we unify them with a non-type-variable.
-newSigTyVar name kind = newTyVar name kind True
-
-newTyVar name kind is_sig
- = do loc <- newIORef Nothing
- return (Var { varName = name
- , realUnique = getKey (nameUnique name)
- , varType = kind
- , varDetails = MutTyVar loc is_sig
- , varInfo = pprPanic "newMutTyVar" (ppr name)
- })
-
-readMutTyVar :: TyVar -> IO (Maybe Type)
-readMutTyVar (Var {varDetails = MutTyVar loc _}) = readIORef loc
-
-writeMutTyVar :: TyVar -> Maybe Type -> IO ()
-writeMutTyVar (Var {varDetails = MutTyVar loc _}) val = writeIORef loc val
+mutTyVarRef :: TyVar -> IORef (Maybe Type)
+mutTyVarRef (Var {varDetails = MutTyVar loc _}) = loc
makeTyVarImmutable :: TyVar -> TyVar
makeTyVarImmutable tyvar = tyvar { varDetails = TyVar}
+
+mutTyVarDetails :: TyVar -> TyVarDetails
+mutTyVarDetails (Var {varDetails = MutTyVar _ details}) = details
\end{code}
setIdName :: Id -> Name -> Id
setIdName = setVarName
-setIdNoDiscard :: Id -> Id
-setIdNoDiscard id
- = WARN( not (isLocalId id), ppr id )
- id { varDetails = LocalId Exported }
+setIdLocalExported :: Id -> Id
+setIdLocalExported id = id { varDetails = LocalId Exported }
zapSpecPragmaId :: Id -> Id
zapSpecPragmaId id
mkId :: Name -> Type -> VarDetails -> IdInfo -> Id
mkId name ty details info
= Var { varName = name,
- realUnique = getKey (nameUnique name), -- Cache the unique
+ realUnique = getKey# (nameUnique name), -- Cache the unique
varType = ty,
varDetails = details,
varInfo = info }
\end{code}
\begin{code}
-isTyVar, isMutTyVar, isSigTyVar :: Var -> Bool
+isTyVar, isMutTyVar :: Var -> Bool
isId, isLocalVar, isLocalId :: Var -> Bool
isGlobalId, isExportedId, isSpecPragmaId :: Var -> Bool
mustHaveLocalBinding :: Var -> Bool
isMutTyVar (Var {varDetails = MutTyVar _ _}) = True
isMutTyVar other = False
-isSigTyVar (Var {varDetails = MutTyVar _ is_sig}) = is_sig
-isSigTyVar other = False
isId var = case varDetails var of
LocalId _ -> True
projects / ghc-hetmet.git / blobdiff