\begin{code}
module TcEnv(
- TcId, TcIdSet, tcInstId,
- tcLookupDataCon,
+ TcId, TcIdSet,
+ TyThing(..), TyThingDetails(..), TcTyThing(..),
- TcEnv, ValueEnv, TcTyThing(..),
-
- initEnv, getEnvTyCons, getEnvClasses,
+ -- Getting stuff from the environment
+ TcEnv, initTcEnv,
+ tcEnvTyCons, tcEnvClasses, tcEnvIds, tcEnvTcIds, tcEnvTyVars,
+ getTcGEnv,
- tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars,
-
- tcLookupTy,
- tcLookupTyCon, tcLookupTyConByKey,
- tcLookupClass, tcLookupClassByKey,
-
- tcExtendGlobalValEnv, tcExtendLocalValEnv,
- tcGetValueEnv, tcSetValueEnv,
- tcAddImportedIdInfo,
+ -- Instance environment, and InstInfo type
+ tcGetInstEnv, tcSetInstEnv,
+ InstInfo(..), pprInstInfo,
+ simpleInstInfoTy, simpleInstInfoTyCon, isLocalInst,
+
+ -- Global environment
+ tcExtendGlobalEnv, tcExtendGlobalValEnv,
+ tcLookupTyCon, tcLookupClass, tcLookupGlobalId, tcLookupDataCon,
+ tcLookupGlobal_maybe, tcLookupGlobal,
+
+ -- Local environment
+ tcExtendKindEnv,
+ tcExtendTyVarEnv, tcExtendTyVarEnvForMeths,
+ tcExtendLocalValEnv, tcLookup,
+
+ -- Global type variables
+ tcGetGlobalTyVars, tcExtendGlobalTyVars,
- tcLookupValue, tcLookupValueMaybe,
- tcLookupValueByKey, tcLookupValueByKeyMaybe,
- explicitLookupValueByKey, explicitLookupValue,
+ -- Random useful things
+ tcAddImportedIdInfo, tcInstId,
- newLocalIds, newLocalId, newSpecPragmaId,
- tcGetGlobalTyVars, tcExtendGlobalTyVars,
+ -- New Ids
+ newLocalId, newSpecPragmaId,
+ newDefaultMethodName, newDFunName,
- badCon, badPrimOp
+ -- Misc
+ isLocalThing, tcSetEnv, explicitLookupId
) where
#include "HsVersions.h"
-import HsTypes ( HsTyVar, getTyVarName )
-import Id ( mkUserLocal, isDataConId_maybe )
-import MkId ( mkSpecPragmaId )
-import Var ( TyVar, Id, setVarName,
- idType, setIdInfo, idInfo, tyVarKind
- )
-import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType,
- tcInstTyVars, zonkTcTyVars,
- TcKind, kindToTcKind
- )
-import VarEnv
-import VarSet
-import Type ( Kind, superKind,
- tyVarsOfType, tyVarsOfTypes, mkTyVarTy, substTy,
- splitForAllTys, splitRhoTy, splitFunTys, substTopTy,
- splitAlgTyConApp_maybe, getTyVar
- )
-import DataCon ( DataCon )
-import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon )
-import Class ( Class )
-
+import RnHsSyn ( RenamedMonoBinds, RenamedSig )
import TcMonad
-
-import BasicTypes ( Arity )
-import IdInfo ( noIdInfo )
-import Name ( Name, OccName, nameOccName, occNameString, mkLocalName,
- maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined,
- isSysLocalName,
- NamedThing(..)
+import TcType ( TcKind, TcType, TcTyVar, TcTyVarSet, TcThetaType,
+ tcInstTyVars, zonkTcTyVars,
+ )
+import Id ( mkUserLocal, isDataConWrapId_maybe )
+import IdInfo ( vanillaIdInfo )
+import MkId ( mkSpecPragmaId )
+import Var ( TyVar, Id, idType, lazySetIdInfo, idInfo )
+import VarSet
+import Type ( Type, ThetaType,
+ tyVarsOfTypes,
+ splitForAllTys, splitRhoTy,
+ getDFunTyKey, splitTyConApp_maybe
+ )
+import DataCon ( DataCon )
+import TyCon ( TyCon )
+import Class ( Class, ClassOpItem, ClassContext )
+import Subst ( substTy )
+import Name ( Name, OccName, NamedThing(..),
+ nameOccName, nameModule, getSrcLoc, mkGlobalName,
+ isLocallyDefined, nameModule_maybe,
+ NameEnv, lookupNameEnv, nameEnvElts,
+ extendNameEnvList, emptyNameEnv
)
-import Unique ( pprUnique10, Unique, Uniquable(..) )
-import FiniteMap ( lookupFM, addToFM )
-import UniqFM
-import Unique ( Uniquable(..) )
-import Util ( zipEqual, zipWith3Equal, mapAccumL )
-import Bag ( bagToList )
-import Maybes ( maybeToBool )
-import FastString ( FastString )
+import OccName ( mkDFunOcc, mkDefaultMethodOcc, occNameString )
+import HscTypes ( DFunId, TypeEnv, HomeSymbolTable, PackageTypeEnv )
+import Module ( Module )
+import InstEnv ( InstEnv, emptyInstEnv )
+import HscTypes ( lookupType, TyThing(..) )
+import Util ( zipEqual )
+import SrcLoc ( SrcLoc )
import Outputable
+
+import IOExts ( newIORef )
\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 :: Name -> Maybe TyThing, -- The type environment at the moment we began this compilation
+
+ tcInsts :: InstEnv, -- All instances (both imported and in this module)
+
+ tcGEnv :: TypeEnv, -- The global type environment we've accumulated while
+ {- NameEnv TyThing-} -- 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 :: HomeSymbolTable -> PackageTypeEnv -> IO TcEnv
+initTcEnv hst pte
+ = do { gtv_var <- newIORef emptyVarSet ;
+ return (TcEnv { tcGST = lookup,
+ tcGEnv = emptyNameEnv,
+ tcInsts = emptyInstEnv,
+ tcLEnv = emptyNameEnv,
+ tcTyVars = gtv_var
+ })}
+ where
+ lookup name = lookupType hst pte name
+
+
+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)]
+
+getTcGEnv (TcEnv { tcGEnv = genv }) = genv
+
+-- 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 -> 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}
+
+
+%************************************************************************
+%* *
+\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
in
tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) ->
let
- rho' = substTopTy tenv rho
+ rho' = substTy tenv rho
(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{TcEnv}
+\subsection{Making new Ids}
%* *
%************************************************************************
-Data type declarations
-~~~~~~~~~~~~~~~~~~~~~
+Constructing new Ids
\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
+newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM TcId
+newLocalId name ty loc
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkUserLocal name uniq ty loc)
-type NameEnv val = UniqFM val -- Keyed by Names
+newSpecPragmaId :: Name -> TcType -> NF_TcM TcId
+newSpecPragmaId name ty
+ = tcGetUnique `thenNF_Tc` \ uniq ->
+ returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name))
+\end{code}
-type TypeEnv = NameEnv (TcKind, Maybe Arity, TcTyThing)
-type ValueEnv = NameEnv Id
+Make a name for the dict fun for an instance decl
-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
+\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)
+ loc)
+ 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))
+ loc)
+\end{code}
+\begin{code}
+isLocalThing :: NamedThing a => Module -> a -> Bool
+ -- True if the thing has a Local name,
+ -- or a Global name from the specified module
+isLocalThing mod thing = case nameModule_maybe (getName thing) of
+ Nothing -> True -- A local name
+ Just m -> m == mod -- A global thing
+\end{code}
+
+%************************************************************************
+%* *
+\subsection{The global environment}
+%* *
+%************************************************************************
-initEnv :: TcRef TcTyVarSet -> TcEnv
-initEnv mut = TcEnv emptyUFM emptyUFM (emptyVarSet, mut)
+\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
-getEnvTyCons (TcEnv te _ _) = [tc | (_, _, ATyCon tc) <- eltsUFM te]
-getEnvClasses (TcEnv te _ _) = [cl | (_, _, AClass cl) <- eltsUFM te]
+tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a
+tcExtendGlobalValEnv ids thing_inside
+ = tcExtendGlobalEnv [(getName id, AnId id) | id <- ids] thing_inside
\end{code}
-The TypeEnv
-~~~~~~~~~~~~
-Extending the type environment.
+\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}
-tcExtendTyVarEnv :: [TyVar] -> TcM s r -> TcM s r
-tcExtendTyVarEnv tyvars scope
- = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope_tvs, gtvs)) ->
+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
+ = 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
+ 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
- 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 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
-- 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
-- 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) ->
+ = tcGetEnv `thenNF_Tc` \ env ->
let
- te' = addListToUFM te stuff
+ le' = extendNameEnvList (tcLEnv env) stuff
+ stuff = [ (getName sig_tv, ATyVar inst_tv)
+ | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars
+ ]
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
- ]
+ tcSetEnv (env {tcLEnv = le'}) thing_inside
+\end{code}
-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 ->
+\begin{code}
+tcExtendLocalValEnv :: [(Name,TcId)] -> TcM a -> TcM a
+tcExtendLocalValEnv names_w_ids thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
let
- new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs
+ 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
- tcNewMutVar new_global_tyvars
+ tc_extend_gtvs (tcTyVars env) extra_global_tyvars `thenNF_Tc` \ gtvs' ->
+ tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside
+\end{code}
+
+
+%************************************************************************
+%* *
+\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
+tcGetGlobalTyVars :: NF_TcM TcTyVarSet
tcGetGlobalTyVars
- = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (_,gtvs)) ->
- tcReadMutVar gtvs `thenNF_Tc` \ global_tvs ->
- zonkTcTyVars (varSetElems global_tvs) `thenNF_Tc` \ global_tys' ->
+ = 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 gtvs global_tvs' `thenNF_Tc_`
+ tcWriteMutVar gtv_var 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 -> pprPanic "tcLookupTy" (ppr 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)
-\end{code}
-
-
-
-
%************************************************************************
%* *
-\subsection{The value environment}
+\subsection{The instance environment}
%* *
%************************************************************************
\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
-
-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
-\end{code}
-
-
-\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
+tcGetInstEnv :: NF_TcM InstEnv
+tcGetInstEnv = tcGetEnv `thenNF_Tc` \ env ->
+ returnNF_Tc (tcInsts env)
- -- 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 `setIdInfo` 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 -> noIdInfo
- Just imported_id -> idInfo imported_id
- -- ToDo: could check that types are the same
-\end{code}
+tcSetInstEnv :: InstEnv -> TcM a -> TcM a
+tcSetInstEnv ie thing_inside
+ = tcGetEnv `thenNF_Tc` \ env ->
+ tcSetEnv (env {tcInsts = ie}) thing_inside
+\end{code}
%************************************************************************
%* *
-\subsection{Constructing new Ids}
+\subsection{The InstInfo type}
%* *
%************************************************************************
+The InstInfo type summarises the information in an instance declaration
+
+ instance c => k (t tvs) where b
+
\begin{code}
-newLocalId :: OccName -> TcType -> NF_TcM s TcId
-newLocalId name ty
- = tcGetUnique `thenNF_Tc` \ uniq ->
- returnNF_Tc (mkUserLocal name uniq ty)
+data InstInfo
+ = InstInfo {
+ iClass :: Class, -- Class, k
+ iTyVars :: [TyVar], -- Type variables, tvs
+ iTys :: [Type], -- The types at which the class is being instantiated
+ iTheta :: ThetaType, -- inst_decl_theta: the original context, c, from the
+ -- instance declaration. It constrains (some of)
+ -- the TyVars above
+ iLocal :: Bool, -- True <=> it's defined in this module
+ iDFunId :: DFunId, -- The dfun id
+ iBinds :: RenamedMonoBinds, -- Bindings, b
+ iLoc :: SrcLoc, -- Source location assoc'd with this instance's defn
+ iPrags :: [RenamedSig] -- User pragmas recorded for generating specialised instances
+ }
-newLocalIds :: [OccName] -> [TcType] -> NF_TcM s [TcId]
-newLocalIds names tys
- = tcGetUniques (length names) `thenNF_Tc` \ uniqs ->
- let
- new_ids = zipWith3Equal "newLocalIds" mk_id names uniqs tys
- mk_id name uniq ty = mkUserLocal name uniq ty
- in
- returnNF_Tc new_ids
+pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info)),
+ nest 4 (ppr (iBinds info))]
-newSpecPragmaId :: Name -> TcType -> NF_TcM s TcId
-newSpecPragmaId name ty
- = tcGetUnique `thenNF_Tc` \ uniq ->
- returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty)
+simpleInstInfoTy :: InstInfo -> Type
+simpleInstInfoTy (InstInfo {iTys = [ty]}) = ty
+
+simpleInstInfoTyCon :: InstInfo -> TyCon
+ -- Gets the type constructor for a simple instance declaration,
+ -- i.e. one of the form instance (...) => C (T a b c) where ...
+simpleInstInfoTyCon inst
+ = case splitTyConApp_maybe (simpleInstInfoTy inst) of
+ Just (tycon, _) -> tycon
+
+isLocalInst :: Module -> InstInfo -> Bool
+isLocalInst mod info = isLocalThing mod (iDFunId info)
\end{code}
%************************************************************************
\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")
+
+notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+>
+ ptext SLIT("is not in scope"))
\end{code}
projects / ghc-hetmet.git / blobdiff