\begin{code}
-#include "HsVersions.h"
-
module TcEnv(
- TcEnv,
+ TcId, TcIdSet,
+ TyThing(..), TyThingDetails(..),
- initEnv, getEnv_LocalIds, getEnv_TyCons, getEnv_Classes,
+ -- Getting stuff from the environment
+ TcEnv, initTcEnv,
+ tcEnvTyCons, tcEnvClasses, tcEnvIds, tcEnvTcIds,
- tcExtendKindEnv, tcExtendTyVarEnv, tcExtendTyConEnv, tcExtendClassEnv,
- tcLookupTyVar, tcLookupTyCon, tcLookupClass, tcLookupClassByKey,
+ -- Instance environment
+ tcGetInstEnv, tcSetInstEnv,
- tcExtendGlobalValEnv, tcExtendLocalValEnv,
- tcLookupLocalValue, tcLookupLocalValueOK,
- tcLookupGlobalValue, tcLookupGlobalValueByKey,
+ -- Global environment
+ tcExtendGlobalEnv, tcExtendGlobalValEnv,
+ tcLookupTyCon, tcLookupClass, tcLookupGlobalId, tcLookupDataCon,
+ tcLookupGlobal_maybe,
- tcTyVarScope, newMonoIds, newLocalIds,
- tcGetGlobalTyVars
- ) where
+ -- Local environment
+ tcExtendKindEnv,
+ tcExtendTyVarEnv, tcExtendTyVarEnvForMeths,
+ tcExtendLocalValEnv,
+ -- Global type variables
+ tcGetGlobalTyVars, tcExtendGlobalTyVars,
-import Ubiq
-import TcMLoop -- for paranoia checking
+ -- Random useful things
+ tcAddImportedIdInfo, tcInstId,
-import Id ( Id(..), GenId, idType, mkUserLocal )
-import TcHsSyn ( TcIdBndr(..) )
-import TcKind ( TcKind, newKindVars, tcKindToKind, kindToTcKind )
-import TcType ( TcType(..), TcMaybe, TcTyVar(..), TcTyVarSet(..), newTyVarTys, zonkTcTyVars )
-import TyVar ( mkTyVar, getTyVarKind, unionTyVarSets, emptyTyVarSet )
-import Type ( tyVarsOfTypes )
-import TyCon ( TyCon, getTyConKind )
-import Class ( Class(..), GenClass, getClassSig )
+ -- New Ids
+ newLocalId, newSpecPragmaId,
+ newDefaultMethodName, newDFunName
+ ) where
-import TcMonad
+#include "HsVersions.h"
-import Name ( Name(..), getNameShortName )
-import PprStyle
-import Pretty
-import Unique ( Unique )
+import TcMonad
+import TcType ( TcKind, TcType, TcTyVar, TcTyVarSet, TcThetaType,
+ tcInstTyVars, zonkTcTyVars,
+ )
+import Id ( mkUserLocal, isDataConWrapId_maybe )
+import IdInfo ( vanillaIdInfo )
+import MkId ( mkSpecPragmaId )
+import Var ( TyVar, Id, setVarName,
+ idType, lazySetIdInfo, idInfo, tyVarKind, UVar,
+ )
+import VarSet
+import VarEnv ( TyVarSubstEnv )
+import Type ( Kind, Type, superKind,
+ tyVarsOfType, tyVarsOfTypes,
+ splitForAllTys, splitRhoTy, splitFunTys,
+ splitAlgTyConApp_maybe, getTyVar, getDFunTyKey
+ )
+import DataCon ( DataCon )
+import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon )
+import Class ( Class, ClassOpItem, ClassContext, classTyCon )
+import Subst ( substTy )
+import Name ( Name, OccName, Provenance(..), ExportFlag(..), NamedThing(..),
+ nameOccName, nameModule, getSrcLoc, mkGlobalName,
+ isLocallyDefined,
+ NameEnv, emptyNameEnv, lookupNameEnv, nameEnvElts,
+ extendNameEnv, extendNameEnvList
+ )
+import OccName ( mkDFunOcc, mkDefaultMethodOcc, occNameString )
+import Module ( Module )
+import Unify ( unifyTyListsX, matchTys )
+import HscTypes ( ModDetails(..), InstEnv, lookupTypeEnv, TyThing(..),
+ GlobalSymbolTable )
+import Unique ( pprUnique10, Unique, Uniquable(..) )
import UniqFM
-import Util ( zipWithEqual, zipWith3Equal, zipLazy, panic )
+import Unique ( Uniquable(..) )
+import Util ( zipEqual, zipWith3Equal, mapAccumL )
+import SrcLoc ( SrcLoc )
+import FastString ( FastString )
+import Maybes
+import Outputable
+import IOExts ( newIORef )
\end{code}
-Data type declarations
-~~~~~~~~~~~~~~~~~~~~~
+%************************************************************************
+%* *
+\subsection{TcEnv}
+%* *
+%************************************************************************
\begin{code}
-data TcEnv s = TcEnv
- (TyVarEnv s)
- (ValueEnv Id) -- Globals
- (ValueEnv (TcIdBndr s)) -- Locals
- (MutableVar s (TcTyVarSet s)) -- Free type variables of locals
- -- ...why mutable? see notes with tcGetGlobalTyVars
- (KindEnv s) -- Gives TcKinds of TyCons and Classes
- TyConEnv
- ClassEnv
-
-type TyVarEnv s = UniqFM (TcKind s, TyVar)
-type TyConEnv = UniqFM TyCon
-type KindEnv s = UniqFM (TcKind s)
-type ClassEnv = UniqFM Class
-type ValueEnv id = UniqFM id
-
-initEnv :: MutableVar s (TcTyVarSet s) -> TcEnv s
-initEnv mut = TcEnv emptyUFM emptyUFM emptyUFM mut emptyUFM emptyUFM emptyUFM
-
-getEnv_LocalIds (TcEnv _ _ ls _ _ _ _) = ls
-getEnv_TyCons (TcEnv _ _ _ _ _ ts _) = ts
-getEnv_Classes (TcEnv _ _ _ _ _ _ cs) = cs
+type TcId = Id -- Type may be a TcType
+type TcIdSet = IdSet
+
+data TcEnv
+ = TcEnv {
+ tcGST :: GlobalSymbolTable, -- The symbol table at the moment we began this compilation
+
+ tcInsts :: InstEnv, -- All instances (both imported and in this module)
+
+ tcGEnv :: NameEnv TyThing, -- The global type environment we've accumulated while
+ -- compiling this module:
+ -- types and classes (both imported and local)
+ -- imported Ids
+ -- (Ids defined in this module are in the local envt)
+
+ tcLEnv :: NameEnv TcTyThing, -- The local type environment: Ids and TyVars
+ -- defined in this module
+
+ tcTyVars :: TcRef TcTyVarSet -- The "global tyvars"
+ -- Namely, the in-scope TyVars bound in tcLEnv, plus the tyvars
+ -- mentioned in the types of Ids bound in tcLEnv
+ -- Why mutable? see notes with tcGetGlobalTyVars
+ }
+
\end{code}
-Making new TcTyVars, with knot tying!
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The Global-Env/Local-Env story
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+During type checking, we keep in the GlobalEnv
+ * All types and classes
+ * All Ids derived from types and classes (constructors, selectors)
+ * Imported Ids
+
+At the end of type checking, we zonk the local bindings,
+and as we do so we add to the GlobalEnv
+ * Locally defined top-level Ids
+
+Why? Because they are now Ids not TcIds. This final GlobalEnv is
+used thus:
+ a) fed back (via the knot) to typechecking the
+ unfoldings of interface signatures
+
+ b) used to augment the GlobalSymbolTable
+
+
\begin{code}
-tcTyVarScope :: [Name] -- Names of some type variables
- -> ([TyVar] -> TcM s a) -- Thing to type check in their scope
- -> TcM s a -- Result
-
-tcTyVarScope tyvar_names thing_inside
- = newKindVars (length tyvar_names) `thenNF_Tc` \ tyvar_kinds ->
-
- fixTc (\ ~(tyvars, _) ->
- -- Ok to look at kinds, but not tyvars!
- tcExtendTyVarEnv tyvar_names (tyvar_kinds `zipLazy` tyvars) (
-
- -- Do the thing inside
- thing_inside tyvars `thenTc` \ result ->
-
- -- Get the tyvar's Kinds from their TcKinds
- mapNF_Tc tcKindToKind tyvar_kinds `thenNF_Tc` \ tyvar_kinds' ->
-
- -- Construct the real TyVars
- let
- tyvars = zipWithEqual mk_tyvar tyvar_names tyvar_kinds'
- mk_tyvar name kind = mkTyVar (getNameShortName name) (getItsUnique name) kind
- in
- returnTc (tyvars, result)
- )) `thenTc` \ (_,result) ->
- returnTc result
+data TcTyThing
+ = AGlobal TyThing -- Used only in the return type of a lookup
+ | ATcId TcId -- Ids defined in this module
+ | ATyVar TyVar -- Type variables
+ | AThing TcKind -- Used temporarily, during kind checking
+-- Here's an example of how the AThing guy is used
+-- Suppose we are checking (forall a. T a Int):
+-- 1. We first bind (a -> AThink kv), where kv is a kind variable.
+-- 2. Then we kind-check the (T a Int) part.
+-- 3. Then we zonk the kind variable.
+-- 4. Now we know the kind for 'a', and we add (a -> ATyVar a::K) to the environment
+
+initTcEnv :: GlobalSymbolTable -> InstEnv -> IO TcEnv
+initTcEnv gst inst_env
+ = do { gtv_var <- newIORef emptyVarSet ;
+ return (TcEnv { tcGST = gst,
+ tcGEnv = emptyNameEnv,
+ tcInsts = inst_env,
+ tcLEnv = emptyNameEnv,
+ tcTyVars = gtv_var
+ })}
+
+tcEnvClasses env = [cl | AClass cl <- nameEnvElts (tcGEnv env)]
+tcEnvTyCons env = [tc | ATyCon tc <- nameEnvElts (tcGEnv env)]
+tcEnvIds env = [id | AnId id <- nameEnvElts (tcGEnv env)]
+tcEnvTyVars env = [tv | ATyVar tv <- nameEnvElts (tcLEnv env)]
+tcEnvTcIds env = [id | ATcId id <- nameEnvElts (tcLEnv env)]
+
+-- This data type is used to help tie the knot
+-- when type checking type and class declarations
+data TyThingDetails = SynTyDetails Type
+ | DataTyDetails ClassContext [DataCon] [Class]
+ | ClassDetails ClassContext [Id] [ClassOpItem] DataCon
\end{code}
-The Kind, TyVar, Class and TyCon envs
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Extending the environments
+%************************************************************************
+%* *
+\subsection{Basic lookups}
+%* *
+%************************************************************************
\begin{code}
-tcExtendKindEnv :: [Name] -> [TcKind s] -> TcM s r -> TcM s r
-tcExtendKindEnv names kinds scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- let
- ke' = addListToUFM ke (names `zip` kinds)
- in
- tcSetEnv (TcEnv tve gve lve gtvs ke' tce ce) scope
+lookup_global :: TcEnv -> Name -> Maybe TyThing
+ -- Try the global envt and then the global symbol table
+lookup_global env name
+ = case lookupNameEnv (tcGEnv env) name of
+ Just thing -> Just thing
+ Nothing -> lookupTypeEnv (tcGST env) name
+
+lookup_local :: TcEnv -> Name -> Maybe TcTyThing
+ -- Try the local envt and then try the global
+lookup_local env name
+ = case lookupNameEnv (tcLEnv env) name of
+ Just thing -> Just thing
+ Nothing -> case lookup_global env name of
+ Just thing -> Just (AGlobal thing)
+ Nothing -> Nothing
+
+explicitLookupId :: TcEnv -> Name -> Maybe Id
+explicitLookupId env name = case lookup_global env name of
+ Just (AnId id) -> Just id
+ other -> Nothing
+\end{code}
-tcExtendTyVarEnv :: [Name] -> [(TcKind s, TyVar)] -> TcM s r -> TcM s r
-tcExtendTyVarEnv tyvar_names kinds_w_tyvars scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- let
- tve' = addListToUFM tve (tyvar_names `zip` kinds_w_tyvars)
- in
- tcSetEnv (TcEnv tve' gve lve gtvs ke tce ce) scope
-tcExtendTyConEnv tycons scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- let
- tce' = addListToUFM_Directly tce [(getItsUnique tycon, tycon) | tycon <- tycons]
- in
- tcSetEnv (TcEnv tve gve lve gtvs ke tce' ce) scope
+%************************************************************************
+%* *
+\subsection{Random useful functions}
+%* *
+%************************************************************************
-tcExtendClassEnv classes scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
+
+\begin{code}
+-- A useful function that takes an occurrence of a global thing
+-- and instantiates its type with fresh type variables
+tcInstId :: Id
+ -> NF_TcM ([TcTyVar], -- It's instantiated type
+ TcThetaType, --
+ TcType) --
+tcInstId id
+ = let
+ (tyvars, rho) = splitForAllTys (idType id)
+ in
+ tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) ->
let
- ce' = addListToUFM_Directly ce [(getItsUnique clas, clas) | clas <- classes]
+ rho' = substTy tenv rho
+ (theta', tau') = splitRhoTy rho'
in
- tcSetEnv (TcEnv tve gve lve gtvs ke tce ce') scope
+ returnNF_Tc (tyvars', theta', tau')
+
+tcAddImportedIdInfo :: TcEnv -> Id -> Id
+tcAddImportedIdInfo unf_env id
+ | isLocallyDefined id -- Don't look up locally defined Ids, because they
+ -- have explicit local definitions, so we get a black hole!
+ = id
+ | otherwise
+ = id `lazySetIdInfo` new_info
+ -- The Id must be returned without a data dependency on maybe_id
+ where
+ new_info = case explicitLookupId unf_env (getName id) of
+ Nothing -> vanillaIdInfo
+ Just imported_id -> idInfo imported_id
+ -- ToDo: could check that types are the same
\end{code}
-Looking up in the environments
+%************************************************************************
+%* *
+\subsection{Making new Ids}
+%* *
+%************************************************************************
+
+Constructing new Ids
+
+\begin{code}
+newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM TcId
+newLocalId name ty loc
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkUserLocal name uniq ty loc)
+
+newSpecPragmaId :: Name -> TcType -> NF_TcM TcId
+newSpecPragmaId name ty
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name))
+\end{code}
+
+Make a name for the dict fun for an instance decl
\begin{code}
-tcLookupTyVar name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- returnNF_Tc (lookupWithDefaultUFM tve (panic "tcLookupTyVar") name)
+newDFunName :: Module -> Class -> [Type] -> SrcLoc -> NF_TcM Name
+newDFunName mod clas (ty:_) loc
+ = tcGetDFunUniq dfun_string `thenNF_Tc` \ inst_uniq ->
+ tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkGlobalName uniq mod
+ (mkDFunOcc dfun_string inst_uniq)
+ (LocalDef loc Exported))
+ where
+ -- Any string that is somewhat unique will do
+ dfun_string = occNameString (getOccName clas) ++ occNameString (getDFunTyKey ty)
+
+newDefaultMethodName :: Name -> SrcLoc -> NF_TcM Name
+newDefaultMethodName op_name loc
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkGlobalName uniq (nameModule op_name)
+ (mkDefaultMethodOcc (getOccName op_name))
+ (LocalDef loc Exported))
+\end{code}
-tcLookupTyCon (WiredInTyCon tc) -- wired in tycons
- = returnNF_Tc (kindToTcKind (getTyConKind tc), tc)
+%************************************************************************
+%* *
+\subsection{The global environment}
+%* *
+%************************************************************************
-tcLookupTyCon name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
+\begin{code}
+tcExtendGlobalEnv :: [(Name, TyThing)] -> TcM r -> TcM r
+tcExtendGlobalEnv bindings thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
let
- tycon = lookupWithDefaultUFM tce (panic "tcLookupTyCon") name
- kind = lookupWithDefaultUFM ke (kindToTcKind (getTyConKind tycon)) name
- -- The KE will bind tycon in the current mutually-recursive set.
- -- If the KE doesn't, then the tycon is already defined, and we
- -- can safely grab the kind from the TyCon itself
+ ge' = extendNameEnvList (tcGEnv env) bindings
in
- returnNF_Tc (kind,tycon)
+ tcSetEnv (env {tcGEnv = ge'}) thing_inside
+
+tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a
+tcExtendGlobalValEnv ids thing_inside
+ = tcExtendGlobalEnv [(getName id, AnId id) | id <- ids] thing_inside
+\end{code}
+
+
+\begin{code}
+tcLookupGlobal_maybe :: Name -> NF_TcM (Maybe TyThing)
+tcLookupGlobal_maybe name
+ = tcGetEnv `thenNF_Tc` \ env ->
+ returnNF_Tc (lookup_global env name)
+\end{code}
+
+A variety of global lookups, when we know what we are looking for.
+
+\begin{code}
+tcLookupGlobal :: Name -> NF_TcM TyThing
+tcLookupGlobal name
+ = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_thing ->
+ case maybe_thing of
+ Just thing -> returnNF_Tc thing
+ other -> notFound "tcLookupGlobal:" name
+
+tcLookupGlobalId :: Name -> NF_TcM Id
+tcLookupGlobalId name
+ = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_id ->
+ case maybe_id of
+ Just (AnId clas) -> returnNF_Tc clas
+ other -> notFound "tcLookupGlobalId:" name
+
+tcLookupDataCon :: Name -> TcM DataCon
+tcLookupDataCon con_name
+ = tcLookupGlobalId con_name `thenNF_Tc` \ con_id ->
+ case isDataConWrapId_maybe con_id of
+ Just data_con -> returnTc data_con
+ Nothing -> failWithTc (badCon con_id)
+tcLookupClass :: Name -> NF_TcM Class
tcLookupClass name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
+ = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_clas ->
+ case maybe_clas of
+ Just (AClass clas) -> returnNF_Tc clas
+ other -> notFound "tcLookupClass:" name
+
+tcLookupTyCon :: Name -> NF_TcM TyCon
+tcLookupTyCon name
+ = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_tc ->
+ case maybe_tc of
+ Just (ATyCon tc) -> returnNF_Tc tc
+ other -> notFound "tcLookupTyCon:" name
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{The local environment}
+%* *
+%************************************************************************
+
+\begin{code}
+tcLookup_maybe :: Name -> NF_TcM (Maybe TcTyThing)
+tcLookup_maybe name
+ = tcGetEnv `thenNF_Tc` \ env ->
+ returnNF_Tc (lookup_local env name)
+
+tcLookup :: Name -> NF_TcM TcTyThing
+tcLookup name
+ = tcLookup_maybe name `thenNF_Tc` \ maybe_thing ->
+ case maybe_thing of
+ Just thing -> returnNF_Tc thing
+ other -> notFound "tcLookup:" name
+ -- Extract the IdInfo from an IfaceSig imported from an interface file
+\end{code}
+
+
+\begin{code}
+tcExtendKindEnv :: [(Name,TcKind)] -> TcM r -> TcM r
+tcExtendKindEnv pairs thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
let
- clas = lookupWithDefaultUFM ce (panic "tcLookupClass") name
- (tyvar, _, _) = getClassSig clas
- kind = lookupWithDefaultUFM ke (kindToTcKind (getTyVarKind tyvar)) name
+ le' = extendNameEnvList (tcLEnv env) [(n, AThing k) | (n,k) <- pairs]
+ -- No need to extend global tyvars for kind checking
in
- returnNF_Tc (kind,clas)
-
-tcLookupClassByKey uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
+ tcSetEnv (env {tcLEnv = le'}) thing_inside
+
+tcExtendTyVarEnv :: [TyVar] -> TcM r -> TcM r
+tcExtendTyVarEnv tyvars thing_inside
+ = tcGetEnv `thenNF_Tc` \ env@(TcEnv {tcLEnv = le, tcTyVars = gtvs}) ->
let
- clas = lookupWithDefaultUFM_Directly ce (panic "tcLookupClas") uniq
+ le' = extendNameEnvList le [ (getName tv, ATyVar tv) | tv <- tyvars]
+ new_tv_set = mkVarSet tyvars
in
- returnNF_Tc (clas)
+ -- It's important to add the in-scope tyvars to the global tyvar set
+ -- as well. Consider
+ -- f (x::r) = let g y = y::r in ...
+ -- Here, g mustn't be generalised. This is also important during
+ -- class and instance decls, when we mustn't generalise the class tyvars
+ -- when typechecking the methods.
+ tc_extend_gtvs gtvs new_tv_set `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside
+
+-- This variant, tcExtendTyVarEnvForMeths, takes *two* bunches of tyvars:
+-- the signature tyvars contain the original names
+-- the instance tyvars are what those names should be mapped to
+-- It's needed when typechecking the method bindings of class and instance decls
+-- It does *not* extend the global tyvars; tcMethodBind does that for itself
+
+tcExtendTyVarEnvForMeths :: [TyVar] -> [TcTyVar] -> TcM r -> TcM r
+tcExtendTyVarEnvForMeths sig_tyvars inst_tyvars thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
+ let
+ le' = extendNameEnvList (tcLEnv env) stuff
+ stuff = [ (getName sig_tv, ATyVar inst_tv)
+ | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars
+ ]
+ in
+ tcSetEnv (env {tcLEnv = le'}) thing_inside
\end{code}
-
-Extending and consulting the value environment
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
\begin{code}
-tcExtendGlobalValEnv ids scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
+tcExtendLocalValEnv :: [(Name,TcId)] -> TcM a -> TcM a
+tcExtendLocalValEnv names_w_ids thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
let
- gve' = addListToUFM_Directly gve [(getItsUnique id, id) | id <- ids]
+ extra_global_tyvars = tyVarsOfTypes [idType id | (name,id) <- names_w_ids]
+ extra_env = [(name, ATcId id) | (name,id) <- names_w_ids]
+ le' = extendNameEnvList (tcLEnv env) extra_env
in
- tcSetEnv (TcEnv tve gve' lve gtvs ke tce ce) scope
+ tc_extend_gtvs (tcTyVars env) extra_global_tyvars `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside
+\end{code}
-tcExtendLocalValEnv names ids scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
- let
- lve' = addListToUFM lve (names `zip` ids)
- extra_global_tyvars = tyVarsOfTypes (map idType ids)
- new_global_tyvars = global_tvs `unionTyVarSets` extra_global_tyvars
- in
- tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' ->
- tcSetEnv (TcEnv tve gve lve' gtvs' ke tce ce) scope
+%************************************************************************
+%* *
+\subsection{The global tyvars}
+%* *
+%************************************************************************
+
+\begin{code}
+tcExtendGlobalTyVars extra_global_tvs thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
+ tc_extend_gtvs (tcTyVars env) extra_global_tvs `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (env {tcTyVars = gtvs'}) thing_inside
+
+tc_extend_gtvs gtvs extra_global_tvs
+ = tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
+ tcNewMutVar (global_tvs `unionVarSet` extra_global_tvs)
\end{code}
@tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment.
the environment.
\begin{code}
-tcGetGlobalTyVars :: NF_TcM s (TcTyVarSet s)
+tcGetGlobalTyVars :: NF_TcM TcTyVarSet
tcGetGlobalTyVars
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
- zonkTcTyVars global_tvs `thenNF_Tc` \ global_tvs' ->
- tcWriteMutVar gtvs global_tvs' `thenNF_Tc_`
+ = tcGetEnv `thenNF_Tc` \ (TcEnv {tcTyVars = gtv_var}) ->
+ tcReadMutVar gtv_var `thenNF_Tc` \ global_tvs ->
+ zonkTcTyVars (varSetElems global_tvs) `thenNF_Tc` \ global_tys' ->
+ let
+ global_tvs' = (tyVarsOfTypes global_tys')
+ in
+ tcWriteMutVar gtv_var global_tvs' `thenNF_Tc_`
returnNF_Tc global_tvs'
\end{code}
-\begin{code}
-tcLookupLocalValue :: Name -> NF_TcM s (Maybe (TcIdBndr s))
-tcLookupLocalValue name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- returnNF_Tc (lookupUFM lve name)
-
-tcLookupLocalValueOK :: String -> Name -> NF_TcM s (TcIdBndr s)
-tcLookupLocalValueOK err name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- returnNF_Tc (lookupWithDefaultUFM lve (panic err) name)
-
-
-tcLookupGlobalValue :: Name -> NF_TcM s Id
-
-tcLookupGlobalValue (WiredInVal id) -- wired in ids
- = returnNF_Tc id
-
-tcLookupGlobalValue name
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- returnNF_Tc (lookupWithDefaultUFM gve def name)
- where
-#ifdef DEBUG
- def = panic ("tcLookupGlobalValue:" ++ ppShow 1000 (ppr PprDebug name))
-#else
- def = panic "tcLookupGlobalValue"
-#endif
+%************************************************************************
+%* *
+\subsection{The instance environment}
+%* *
+%************************************************************************
-tcLookupGlobalValueByKey :: Unique -> NF_TcM s Id
-tcLookupGlobalValueByKey uniq
- = tcGetEnv `thenNF_Tc` \ (TcEnv tve gve lve gtvs ke tce ce) ->
- returnNF_Tc (lookupWithDefaultUFM_Directly gve def uniq)
- where
-#ifdef DEBUG
- def = panic ("tcLookupGlobalValueByKey:" ++ ppShow 1000 (ppr PprDebug uniq))
-#else
- def = panic "tcLookupGlobalValueByKey"
-#endif
+\begin{code}
+tcGetInstEnv :: NF_TcM InstEnv
+tcGetInstEnv = tcGetEnv `thenNF_Tc` \ env ->
+ returnNF_Tc (tcInsts env)
-\end{code}
+tcSetInstEnv :: InstEnv -> TcM a -> TcM a
+tcSetInstEnv ie thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
+ tcSetEnv (env {tcInsts = ie}) thing_inside
+\end{code}
-Constructing new Ids
-~~~~~~~~~~~~~~~~~~~~
+%************************************************************************
+%* *
+\subsection{Errors}
+%* *
+%************************************************************************
\begin{code}
-newMonoIds :: [Name] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a
-newMonoIds names kind m
- = newTyVarTys no_of_names kind `thenNF_Tc` \ tys ->
- tcGetUniques no_of_names `thenNF_Tc` \ uniqs ->
- let
- new_ids = zipWith3Equal mk_id names uniqs tys
- mk_id name uniq ty = mkUserLocal (getOccurrenceName name) uniq ty
- (getSrcLoc name)
- in
- tcExtendLocalValEnv names new_ids (m new_ids)
- where
- no_of_names = length names
+badCon con_id = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor")
-newLocalIds :: [FAST_STRING] -> [TcType s] -> NF_TcM s [TcIdBndr s]
-newLocalIds names tys
- = tcGetSrcLoc `thenNF_Tc` \ loc ->
- tcGetUniques (length names) `thenNF_Tc` \ uniqs ->
- let
- new_ids = zipWith3Equal mk_id names uniqs tys
- mk_id name uniq ty = mkUserLocal name uniq ty loc
- in
- returnNF_Tc new_ids
+notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+>
+ ptext SLIT("is not in scope"))
\end{code}
-
-
projects / ghc-hetmet.git / blobdiff