X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=13ce1ef2898b9a9abe5676c25bbd0a65320adb0b;hb=c5eb828c4d5ec8bb278d0bfef8dd0c0d12e32ffe;hp=4fb993e868ea308e1d48970e66560deae90d3466;hpb=4e7d56fde0f44d38bbb9a6fc72cf9c603264899d;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 4fb993e..13ce1ef 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,114 +1,214 @@ \begin{code} module TcEnv( - TcId, TcIdSet, tcInstId, - tcLookupDataCon, + TcId, TcIdSet, + TyThing(..), TyThingDetails(..), - TcEnv, ValueEnv, TcTyThing(..), - - initEnv, getEnvTyCons, getEnvClasses, getAllEnvTyCons, + -- Getting stuff from the environment + TcEnv, initTcEnv, + tcEnvTyCons, tcEnvClasses, tcEnvIds, tcEnvTcIds, - tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars, - - tcLookupTy, - tcLookupTyCon, tcLookupTyConByKey, - tcLookupClass, tcLookupClassByKey, + -- Instance environment + tcGetInstEnv, tcSetInstEnv, - tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcGetValueEnv, tcSetValueEnv, - tcAddImportedIdInfo, + -- Global environment + tcExtendGlobalEnv, tcExtendGlobalValEnv, + tcLookupTy, tcLookupTyCon, tcLookupClass, tcLookupGlobalId, tcLookupDataCon, - tcLookupValue, tcLookupValueMaybe, - tcLookupValueByKey, tcLookupValueByKeyMaybe, - explicitLookupValueByKey, explicitLookupValue, + -- Local environment + tcExtendKindEnv, + tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, + tcExtendLocalValEnv, - newLocalId, newSpecPragmaId, + -- Global type variables tcGetGlobalTyVars, tcExtendGlobalTyVars, - badCon, badPrimOp + -- Random useful things + tcAddImportedIdInfo, tcInstId, + + -- New Ids + newLocalId, newSpecPragmaId, + newDefaultMethodName, newDFunName ) where #include "HsVersions.h" -import HsTypes ( HsTyVar, getTyVarName ) -import Id ( mkUserLocal, isDataConId_maybe ) +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 - ) -import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType, - tcInstTyVars, zonkTcTyVars, - TcKind, kindToTcKind + idType, lazySetIdInfo, idInfo, tyVarKind, UVar, ) -import VarEnv import VarSet -import Type ( Kind, superKind, - tyVarsOfType, tyVarsOfTypes, mkTyVarTy, +import VarEnv ( TyVarSubstEnv ) +import Type ( Kind, Type, superKind, + tyVarsOfType, tyVarsOfTypes, splitForAllTys, splitRhoTy, splitFunTys, - splitAlgTyConApp_maybe, getTyVar + splitAlgTyConApp_maybe, getTyVar, getDFunTyKey ) -import Subst ( substTy ) -import UsageSPUtils ( unannotTy ) import DataCon ( DataCon ) import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon ) -import Class ( Class, classTyCon ) - -import TcMonad - -import BasicTypes ( Arity ) -import IdInfo ( vanillaIdInfo ) -import Name ( Name, OccName, nameOccName, getSrcLoc, - maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined, - NamedThing(..) - ) -import Unique ( pprUnique10, Unique, Uniquable(..) ) -import FiniteMap ( lookupFM, addToFM ) +import Class ( Class, ClassOpItem, ClassContext, classTyCon ) +import Subst ( substTy ) +import Name ( Name, OccName, Provenance(..), ExportFlag(..), NamedThing(..), + nameOccName, nameModule, getSrcLoc, mkGlobalName, + maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined, + NameEnv, emptyNameEnv, lookupNameEnv, nameEnvElts, + extendNameEnv, extendNameEnvList + ) +import OccName ( mkDFunOcc, mkDefaultMethodOcc, occNameString ) +import Module ( Module ) +import Unify ( unifyTyListsX, matchTys ) +import HscTypes ( ModDetails(..), InstEnv, lookupTypeEnv ) +import Unique ( pprUnique10, Unique, Uniquable(..) ) import UniqFM -import Unique ( Uniquable(..) ) -import Util ( zipEqual, zipWith3Equal, mapAccumL ) -import Bag ( bagToList ) -import Maybes ( maybeToBool, catMaybes ) -import SrcLoc ( SrcLoc ) +import Unique ( Uniquable(..) ) +import Util ( zipEqual, zipWith3Equal, mapAccumL ) +import SrcLoc ( SrcLoc ) import FastString ( FastString ) +import Maybes import Outputable \end{code} %************************************************************************ %* * -\subsection{TcId} +\subsection{TcEnv} %* * %************************************************************************ - \begin{code} type TcId = Id -- Type may be a TcType type TcIdSet = IdSet -tcLookupDataCon :: Name -> TcM s (DataCon, [TcType], TcType) -tcLookupDataCon con_name - = tcLookupValue con_name `thenNF_Tc` \ con_id -> - case isDataConId_maybe con_id of { - Nothing -> failWithTc (badCon con_id); - Just data_con -> - - tcInstId con_id `thenNF_Tc` \ (_, _, con_tau) -> - -- Ignore the con_theta; overloaded constructors only - -- behave differently when called, not when used for - -- matching. - let - (arg_tys, result_ty) = splitFunTys con_tau - in - ASSERT( maybeToBool (splitAlgTyConApp_maybe result_ty) ) - returnTc (data_con, arg_tys, result_ty) } +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} + +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} +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} + + +%************************************************************************ +%* * +\subsection{Basic lookups} +%* * +%************************************************************************ + +\begin{code} +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 -> 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} + + +%************************************************************************ +%* * +\subsection{Random useful functions} +%* * +%************************************************************************ + + +\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 s ([TcTyVar], -- It's instantiated type + -> NF_TcM ([TcTyVar], -- It's instantiated type TcThetaType, -- TcType) -- tcInstId id = let - (tyvars, rho) = splitForAllTys (unannotTy (idType id)) + (tyvars, rho) = splitForAllTys (idType id) in tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) -> let @@ -116,73 +216,172 @@ tcInstId id (theta', tau') = splitRhoTy rho' in 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} + + +%************************************************************************ +%* * +\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} -Between the renamer and the first invocation of the UsageSP inference, -identifiers read from interface files will have usage information in -their types, whereas other identifiers will not. The unannotTy here -in @tcInstId@ prevents this information from pointlessly propagating -further prior to the first usage inference. +Make a name for the dict fun for an instance decl + +\begin{code} +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} %************************************************************************ %* * -\subsection{TcEnv} +\subsection{The global environment} %* * %************************************************************************ -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ +\begin{code} +tcExtendGlobalEnv :: [(Name, TyThing)] -> TcM r -> TcM r +tcExtendGlobalEnv bindings thing_inside + = tcGetEnv `thenNF_Tc` \ env -> + let + ge' = extendNameEnvList (tcGEnv env) bindings + in + 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} -data TcEnv = TcEnv - TypeEnv - ValueEnv - (TcTyVarSet, -- The in-scope TyVars - TcRef TcTyVarSet) -- Free type variables of the value env - -- ...why mutable? see notes with tcGetGlobalTyVars - -- Includes the in-scope tyvars - -type NameEnv val = UniqFM val -- Keyed by Names - -type TypeEnv = NameEnv (TcKind, Maybe Arity, TcTyThing) -type ValueEnv = NameEnv Id - -data TcTyThing = ATyVar TcTyVar -- Mutable only so that the kind can be mutable - -- if the kind is mutable, the tyvar must be so that - -- zonking works - | ATyCon TyCon - | AClass Class - - -initEnv :: TcRef TcTyVarSet -> TcEnv -initEnv mut = TcEnv emptyUFM emptyUFM (emptyVarSet, mut) - -getEnvTyCons (TcEnv te _ _) = [tc | (_, _, ATyCon tc) <- eltsUFM te] -getEnvClasses (TcEnv te _ _) = [cl | (_, _, AClass cl) <- eltsUFM te] -getAllEnvTyCons (TcEnv te _ _) = catMaybes (map gettc (eltsUFM te)) - where - gettc (_,_, ATyCon tc) = Just tc - gettc (_,_, AClass cl) = Just (classTyCon cl) - gettc _ = Nothing +tcLookupGlobal_maybe :: Name -> NF_TcM (Maybe TyThing) +tcLookupGlobal_maybe name + = tcGetEnv `thenNF_Tc` \ env -> + returnNF_Tc (lookup_global env name) \end{code} -The TypeEnv -~~~~~~~~~~~~ +A variety of global lookups, when we know what we are looking for. -Extending the type environment. +\begin{code} +tcLookupGlobal :: Name -> NF_TcM TyThing + = 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 id + 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 + = 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} -tcExtendTyVarEnv :: [TyVar] -> TcM s r -> TcM s r -tcExtendTyVarEnv tyvars scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope_tvs, gtvs)) -> +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 - extend_list = [ (getName tv, (kindToTcKind (tyVarKind tv), Nothing, ATyVar tv)) - | tv <- tyvars - ] - te' = addListToUFM te extend_list - new_tv_set = mkVarSet tyvars - in_scope_tvs' = in_scope_tvs `unionVarSet` new_tv_set + le' = extendNameEnvList (tcLEnv env) [(n, AThing k) | (n,k) <- pairs] + -- No need to extend global tyvars for kind checking + in + 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 + le' = extendNameEnvList le [ (getName tv, ATyVar tv) | tv <- tyvars] + new_tv_set = mkVarSet tyvars in -- It's important to add the in-scope tyvars to the global tyvar set -- as well. Consider @@ -191,7 +390,7 @@ tcExtendTyVarEnv tyvars scope -- 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 (TcEnv te' ve (in_scope_tvs', gtvs')) scope + tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside -- This variant, tcExtendTyVarEnvForMeths, takes *two* bunches of tyvars: -- the signature tyvars contain the original names @@ -199,231 +398,84 @@ tcExtendTyVarEnv tyvars scope -- 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 s r -> TcM s r +tcExtendTyVarEnvForMeths :: [TyVar] -> [TcTyVar] -> TcM r -> TcM r tcExtendTyVarEnvForMeths sig_tyvars inst_tyvars thing_inside - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - let - te' = addListToUFM te stuff - in - tcSetEnv (TcEnv te' ve gtvs) thing_inside - where - stuff = [ (getName sig_tv, (kindToTcKind (tyVarKind inst_tv), Nothing, ATyVar inst_tv)) - | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars - ] - -tcExtendGlobalTyVars extra_global_tvs scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope,gtvs)) -> - tc_extend_gtvs gtvs extra_global_tvs `thenNF_Tc` \ gtvs' -> - tcSetEnv (TcEnv te ve (in_scope,gtvs')) scope - -tc_extend_gtvs gtvs extra_global_tvs - = tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> + = tcGetEnv `thenNF_Tc` \ env -> let - new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs + le' = extendNameEnvList (tcLEnv env) stuff + stuff = [ (getName sig_tv, ATyVar inst_tv) + | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars + ] in - tcNewMutVar new_global_tyvars + tcSetEnv (env {tcLEnv = le'}) thing_inside \end{code} -@tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment. -To improve subsequent calls to the same function it writes the zonked set back into -the environment. \begin{code} -tcGetGlobalTyVars :: NF_TcM s TcTyVarSet -tcGetGlobalTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (_,gtvs)) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - zonkTcTyVars (varSetElems global_tvs) `thenNF_Tc` \ global_tys' -> +tcExtendLocalValEnv :: [(Name,TcId)] -> TcM a -> TcM a +tcExtendLocalValEnv names_w_ids thing_inside + = tcGetEnv `thenNF_Tc` \ env -> let - global_tvs' = (tyVarsOfTypes global_tys') + 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 - tcWriteMutVar gtvs global_tvs' `thenNF_Tc_` - returnNF_Tc global_tvs' - -tcGetInScopeTyVars :: NF_TcM s [TcTyVar] -tcGetInScopeTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope_tvs, gtvs)) -> - returnNF_Tc (varSetElems in_scope_tvs) -\end{code} - - -Type constructors and classes - -\begin{code} -tcExtendTypeEnv :: [(Name, (TcKind, Maybe Arity, TcTyThing))] -> TcM s r -> TcM s r -tcExtendTypeEnv bindings scope - = ASSERT( null [tv | (_, (_,_,ATyVar tv)) <- bindings] ) - -- Not for tyvars; use tcExtendTyVarEnv - tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - let - te' = addListToUFM te bindings - in - tcSetEnv (TcEnv te' ve gtvs) scope -\end{code} - - -Looking up in the environments. - -\begin{code} -tcLookupTy :: Name -> NF_TcM s (TcKind, Maybe Arity, TcTyThing) -tcLookupTy name - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM te name of { - Just thing -> returnNF_Tc thing ; - Nothing -> - - case maybeWiredInTyConName name of - Just tc -> returnNF_Tc (kindToTcKind (tyConKind tc), maybe_arity, ATyCon tc) - where - maybe_arity | isSynTyCon tc = Just (tyConArity tc) - | otherwise = Nothing - - Nothing -> -- This can happen if an interface-file - -- unfolding is screwed up - failWithTc (tyNameOutOfScope name) - } - -tcLookupClass :: Name -> NF_TcM s Class -tcLookupClass name - = tcLookupTy name `thenNF_Tc` \ (_, _, AClass clas) -> - returnNF_Tc clas - -tcLookupTyCon :: Name -> NF_TcM s TyCon -tcLookupTyCon name - = tcLookupTy name `thenNF_Tc` \ (_, _, ATyCon tycon) -> - returnNF_Tc tycon - -tcLookupClassByKey :: Unique -> NF_TcM s Class -tcLookupClassByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM_Directly te key of - Just (_, _, AClass cl) -> returnNF_Tc cl - other -> pprPanic "tcLookupClassByKey:" (pprUnique10 key) - -tcLookupTyConByKey :: Unique -> NF_TcM s TyCon -tcLookupTyConByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM_Directly te key of - Just (_, _, ATyCon tc) -> returnNF_Tc tc - other -> pprPanic "tcLookupTyConByKey:" (pprUnique10 key) + tc_extend_gtvs (tcTyVars env) extra_global_tyvars `thenNF_Tc` \ gtvs' -> + tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside \end{code} - - %************************************************************************ %* * -\subsection{The value environment} +\subsection{The global tyvars} %* * %************************************************************************ \begin{code} -tcExtendGlobalValEnv :: [Id] -> TcM s a -> TcM s a -tcExtendGlobalValEnv ids scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - let - ve' = addListToUFM_Directly ve [(getUnique id, id) | id <- ids] - in - tcSetEnv (TcEnv te ve' gtvs) scope +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 -tcExtendLocalValEnv :: [(Name,TcId)] -> TcM s a -> TcM s a -tcExtendLocalValEnv names_w_ids scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope_tvs,gtvs)) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - let - ve' = addListToUFM ve names_w_ids - extra_global_tyvars = tyVarsOfTypes (map (idType . snd) names_w_ids) - in - tc_extend_gtvs gtvs extra_global_tyvars `thenNF_Tc` \ gtvs' -> - tcSetEnv (TcEnv te ve' (in_scope_tvs,gtvs')) scope +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. +To improve subsequent calls to the same function it writes the zonked set back into +the environment. \begin{code} -tcLookupValue :: Name -> NF_TcM s Id -- Panics if not found -tcLookupValue name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc id - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM ve def name) - where - def = pprPanic "tcLookupValue:" (ppr name) - -tcLookupValueMaybe :: Name -> NF_TcM s (Maybe Id) -tcLookupValueMaybe name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc (Just id) - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupUFM ve name) - -tcLookupValueByKey :: Unique -> NF_TcM s Id -- Panics if not found -tcLookupValueByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (explicitLookupValueByKey ve key) - -tcLookupValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id) -tcLookupValueByKeyMaybe key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupUFM_Directly ve key) - -tcGetValueEnv :: NF_TcM s ValueEnv -tcGetValueEnv - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc ve - -tcSetValueEnv :: ValueEnv -> TcM s a -> TcM s a -tcSetValueEnv ve scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te _ gtvs) -> - tcSetEnv (TcEnv te ve gtvs) scope - --- Non-monadic version, environment given explicitly -explicitLookupValueByKey :: ValueEnv -> Unique -> Id -explicitLookupValueByKey ve key - = lookupWithDefaultUFM_Directly ve def key - where - def = pprPanic "lookupValueByKey:" (pprUnique10 key) - -explicitLookupValue :: ValueEnv -> Name -> Maybe Id -explicitLookupValue ve name - = case maybeWiredInIdName name of - Just id -> Just id - Nothing -> lookupUFM ve name - - -- Extract the IdInfo from an IfaceSig imported from an interface file -tcAddImportedIdInfo :: ValueEnv -> 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 = -- pprTrace "tcAdd" (ppr id) $ - case explicitLookupValue unf_env (getName id) of - Nothing -> vanillaIdInfo - Just imported_id -> idInfo imported_id - -- ToDo: could check that types are the same +tcGetGlobalTyVars :: NF_TcM TcTyVarSet +tcGetGlobalTyVars + = 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} %************************************************************************ %* * -\subsection{Constructing new Ids} +\subsection{The instance environment} %* * %************************************************************************ \begin{code} -newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM s TcId -newLocalId name ty loc - = tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkUserLocal name uniq ty loc) +tcGetInstEnv :: NF_TcM InstEnv +tcGetInstEnv = tcGetEnv `thenNF_Tc` \ env -> + returnNF_Tc (tcInsts env) -newSpecPragmaId :: Name -> TcType -> NF_TcM s TcId -newSpecPragmaId name ty - = tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name)) -\end{code} +tcSetInstEnv :: InstEnv -> TcM a -> TcM a +tcSetInstEnv ie thing_inside + = tcGetEnv `thenNF_Tc` \ env -> + tcSetEnv (env {tcInsts = ie}) thing_inside +\end{code} %************************************************************************ @@ -433,11 +485,8 @@ newSpecPragmaId name ty %************************************************************************ \begin{code} -badCon con_id - = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor") -badPrimOp op - = quotes (ppr op) <+> ptext SLIT("is not a primop") +badCon con_id = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor") -tyNameOutOfScope name - = quotes (ppr name) <+> ptext SLIT("is not in scope") +notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+> + ptext SLIT("is not in scope")) \end{code}