X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=f2e0d1da32ed6ae0c00423099e514ebd0d63092d;hb=5e3f005d3012472e422d4ffd7dca5c21a80fca80;hp=6106df145d59eba354b8c8d40dc77b3faa37973f;hpb=83817d01dff687643eee23218435b968ba358a25;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 6106df1..f2e0d1d 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,279 +1,465 @@ \begin{code} module TcEnv( - TcIdOcc(..), TcIdBndr, tcIdType, tcIdTyVars, tcInstId, + TcId, TcIdSet, + TyThing(..), TyThingDetails(..), TcTyThing(..), - TcEnv, - - initEnv, getEnv_LocalIds, getEnv_TyCons, getEnv_Classes, + -- Getting stuff from the environment + TcEnv, initTcEnv, + tcEnvTyCons, tcEnvClasses, tcEnvIds, tcLEnvElts, + getTcGEnv, - tcExtendTyVarEnv, tcLookupTyVar, + -- Instance environment, and InstInfo type + tcGetInstEnv, tcSetInstEnv, + InstInfo(..), pprInstInfo, + simpleInstInfoTy, simpleInstInfoTyCon, + + -- Global environment + tcExtendGlobalEnv, tcExtendGlobalValEnv, tcExtendGlobalTypeEnv, + tcLookupTyCon, tcLookupClass, tcLookupGlobalId, tcLookupDataCon, + tcLookupGlobal_maybe, tcLookupGlobal, + + -- Local environment + tcExtendKindEnv, tcLookupLocalIds, tcInLocalScope, + tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, + tcExtendLocalValEnv, tcLookup, tcLookup_maybe, tcLookupId, - tcExtendTyConEnv, tcLookupTyCon, tcLookupTyConByKey, - tcExtendClassEnv, tcLookupClass, tcLookupClassByKey, - tcGetTyConsAndClasses, + -- Global type variables + tcGetGlobalTyVars, tcExtendGlobalTyVars, - tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcLookupLocalValue, tcLookupLocalValueOK, tcLookupLocalValueByKey, - tcLookupGlobalValue, tcLookupGlobalValueByKey, tcLookupGlobalValueMaybe, - tcAddImportedIdInfo, tcExplicitLookupGlobal, - tcLookupGlobalValueByKeyMaybe, + -- Random useful things + RecTcEnv, tcAddImportedIdInfo, tcLookupRecId, tcLookupRecId_maybe, - newMonoIds, newLocalIds, newLocalId, newSpecPragmaId, - tcGetGlobalTyVars, tcExtendGlobalTyVars + -- New Ids + newLocalName, newDFunName, + + -- Misc + isLocalThing, tcSetEnv ) where #include "HsVersions.h" -import MkId ( mkUserLocal, mkUserId, mkSpecPragmaId ) -import Id ( Id, GenId, idType, replaceIdInfo, idInfo ) -import TcKind ( TcKind, kindToTcKind, Kind ) -import TcType ( TcType, TcMaybe, TcTyVar, TcTyVarSet, TcThetaType, - newTyVarTys, tcInstTyVars, zonkTcTyVars, tcInstType - ) -import TyVar ( mkTyVarSet, unionTyVarSets, emptyTyVarSet, TyVar ) -import Type ( tyVarsOfType, tyVarsOfTypes, splitForAllTys, splitRhoTy ) -import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon, Arity ) -import Class ( Class ) - +import RnHsSyn ( RenamedMonoBinds, RenamedSig ) import TcMonad - -import IdInfo ( noIdInfo ) -import Name ( Name, OccName(..), nameOccName, - maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined, - NamedThing(..) +import TcMType ( zonkTcTyVarsAndFV ) +import TcType ( Type, ThetaType, TcKind, TcTyVar, TcTyVarSet, + tyVarsOfTypes, tcSplitDFunTy, + getDFunTyKey, tcTyConAppTyCon + ) +import Id ( idName, isDataConWrapId_maybe ) +import IdInfo ( vanillaIdInfo ) +import Var ( TyVar, Id, idType, lazySetIdInfo, idInfo ) +import VarSet +import DataCon ( DataCon ) +import TyCon ( TyCon ) +import Class ( Class, ClassOpItem ) +import Name ( Name, NamedThing(..), + getSrcLoc, mkLocalName, isLocalName, nameIsLocalOrFrom ) -import Unique ( pprUnique10{-, pprUnique ToDo:rm-}, Unique, Uniquable(..) ) -import UniqFM -import Util ( zipEqual, zipWithEqual, zipWith3Equal ) -import Maybes ( maybeToBool ) +import NameEnv ( NameEnv, lookupNameEnv, nameEnvElts, elemNameEnv, + extendNameEnvList, emptyNameEnv, plusNameEnv ) +import OccName ( mkDFunOcc, occNameString ) +import HscTypes ( DFunId, + PackageTypeEnv, TypeEnv, + extendTypeEnvList, extendTypeEnvWithIds, + typeEnvTyCons, typeEnvClasses, typeEnvIds, + HomeSymbolTable + ) +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, TcIdOcc} +\subsection{TcEnv} %* * %************************************************************************ - \begin{code} -type TcIdBndr s = GenId (TcType s) -- Binders are all TcTypes -data TcIdOcc s = TcId (TcIdBndr s) -- Bindees may be either - | RealId Id +type TcId = Id -- Type may be a TcType +type TcIdSet = IdSet -instance Eq (TcIdOcc s) where - (TcId id1) == (TcId id2) = id1 == id2 - (RealId id1) == (RealId id2) = id1 == id2 - _ == _ = False +data TcEnv + = TcEnv { + tcGST :: Name -> Maybe TyThing, -- The type environment at the moment we began this compilation -instance Ord (TcIdOcc s) where - (TcId id1) `compare` (TcId id2) = id1 `compare` id2 - (RealId id1) `compare` (RealId id2) = id1 `compare` id2 - (TcId _) `compare` (RealId _) = LT - (RealId _) `compare` (TcId _) = GT + tcInsts :: InstEnv, -- All instances (both imported and in this module) -instance Outputable (TcIdOcc s) where - ppr (TcId id) = ppr id - ppr (RealId id) = ppr id + 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 start in the local envt, + -- though they move to the global envt during zonking) -instance NamedThing (TcIdOcc s) where - getName (TcId id) = getName id - getName (RealId id) = getName id + 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 + } -tcIdType :: TcIdOcc s -> TcType s -tcIdType (TcId id) = idType id -tcIdType (RealId id) = pprPanic "tcIdType:" (ppr id) +\end{code} -tcIdTyVars (TcId id) = tyVarsOfType (idType id) -tcIdTyVars (RealId _) = emptyTyVarSet -- Top level Ids have no free type variables +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 --- 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 s], -- It's instantiated type - TcThetaType s, -- - TcType s) -- +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} +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 | isLocalName name = Nothing + | otherwise = lookupType hst pte name + + +tcEnvClasses env = typeEnvClasses (tcGEnv env) +tcEnvTyCons env = typeEnvTyCons (tcGEnv env) +tcEnvIds env = typeEnvIds (tcGEnv env) +tcLEnvElts env = nameEnvElts (tcLEnv env) + +getTcGEnv (TcEnv { tcGEnv = genv }) = genv + +tcInLocalScope :: TcEnv -> Name -> Bool +tcInLocalScope env v = v `elemNameEnv` (tcLEnv env) +\end{code} + +\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 -tcInstId id - = let - (tyvars, rho) = splitForAllTys (idType id) - in - tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) -> - tcInstType tenv rho `thenNF_Tc` \ rho' -> - let - (theta', tau') = splitRhoTy rho' - in - returnNF_Tc (tyvars', theta', tau') \end{code} +This data type is used to help tie the knot + when type checking type and class declarations + +\begin{code} +data TyThingDetails = SynTyDetails Type + | DataTyDetails ThetaType [DataCon] [Id] + | ClassDetails ThetaType [Id] [ClassOpItem] DataCon + | ForeignTyDetails -- Nothing yet +\end{code} %************************************************************************ %* * -\subsection{TcEnv} +\subsection{Basic lookups} %* * %************************************************************************ -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ +\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 +\end{code} \begin{code} -data TcEnv s = TcEnv - (TyVarEnv s) - (TyConEnv s) - (ClassEnv s) - (ValueEnv Id) -- Globals - (ValueEnv (TcIdBndr s)) -- Locals - (TcRef s (TcTyVarSet s)) -- Free type variables of locals - -- ...why mutable? see notes with tcGetGlobalTyVars - -type TyVarEnv s = UniqFM (TcKind s, TyVar) -type TyConEnv s = UniqFM (TcKind s, Maybe Arity, TyCon) -- Arity present for Synonyms only -type ClassEnv s = UniqFM ([TcKind s], Class) -- The kinds are the kinds of the args - -- to the class -type ValueEnv id = UniqFM id - -initEnv :: TcRef s (TcTyVarSet s) -> TcEnv s -initEnv mut = TcEnv emptyUFM emptyUFM emptyUFM emptyUFM emptyUFM mut - -getEnv_LocalIds (TcEnv _ _ _ _ ls _) = eltsUFM ls -getEnv_TyCons (TcEnv _ ts _ _ _ _) = [tycon | (_, _, tycon) <- eltsUFM ts] -getEnv_Classes (TcEnv _ _ cs _ _ _) = [clas | (_, clas) <- eltsUFM cs] +type RecTcEnv = TcEnv +-- This environment is used for getting the 'right' IdInfo +-- on imported things and for looking up Ids in unfoldings +-- The environment doesn't have any local Ids in it + +tcAddImportedIdInfo :: RecTcEnv -> Id -> Id +tcAddImportedIdInfo env id + = id `lazySetIdInfo` new_info + -- The Id must be returned without a data dependency on maybe_id + where + new_info = case tcLookupRecId_maybe env (idName id) of + Nothing -> pprTrace "tcAddIdInfo" (ppr id) vanillaIdInfo + Just imported_id -> idInfo imported_id + -- ToDo: could check that types are the same + +tcLookupRecId_maybe :: RecTcEnv -> Name -> Maybe Id +tcLookupRecId_maybe env name = case lookup_global env name of + Just (AnId id) -> Just id + other -> Nothing + +tcLookupRecId :: RecTcEnv -> Name -> Id +tcLookupRecId env name = case lookup_global env name of + Just (AnId id) -> id + Nothing -> pprPanic "tcLookupRecId" (ppr name) \end{code} -Type variable env -~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{Making new Ids} +%* * +%************************************************************************ + +Constructing new Ids + \begin{code} -tcExtendTyVarEnv :: [Name] -> [(TcKind s, TyVar)] -> TcM s r -> TcM s r -tcExtendTyVarEnv names kinds_w_types scope - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - tve' = addListToUFM tve (zipEqual "tcTyVarScope" names kinds_w_types) - in - tcSetEnv (TcEnv tve' tce ce gve lve gtvs) scope +newLocalName :: Name -> NF_TcM Name +newLocalName name -- Make a clone + = tcGetUnique `thenNF_Tc` \ uniq -> + returnNF_Tc (mkLocalName uniq (getOccName name) (getSrcLoc name)) \end{code} -The Kind, TyVar, Class and TyCon envs -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Make a name for the dict fun for an instance decl. +It's a *local* name for the moment. The CoreTidy pass +will globalise it. + +\begin{code} +newDFunName :: Class -> [Type] -> SrcLoc -> NF_TcM Name +newDFunName clas (ty:_) loc + = tcGetUnique `thenNF_Tc` \ uniq -> + returnNF_Tc (mkLocalName uniq (mkDFunOcc dfun_string) loc) + where + -- Any string that is somewhat unique will do + dfun_string = occNameString (getOccName clas) ++ occNameString (getDFunTyKey ty) -Extending the environments. +newDFunName clas [] loc = pprPanic "newDFunName" (ppr clas <+> ppr loc) +\end{code} \begin{code} -tcExtendTyConEnv :: [(Name, (TcKind s, Maybe Arity, TyCon))] -> TcM s r -> TcM s r +isLocalThing :: NamedThing a => Module -> a -> Bool +isLocalThing mod thing = nameIsLocalOrFrom mod (getName thing) +\end{code} + +%************************************************************************ +%* * +\subsection{The global environment} +%* * +%************************************************************************ -tcExtendTyConEnv bindings scope - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> +\begin{code} +tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r +tcExtendGlobalEnv things thing_inside + = tcGetEnv `thenNF_Tc` \ env -> let - tce' = addListToUFM tce bindings + ge' = extendTypeEnvList (tcGEnv env) things in - tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope + tcSetEnv (env {tcGEnv = ge'}) thing_inside + +tcExtendGlobalTypeEnv :: TypeEnv -> TcM r -> TcM r +tcExtendGlobalTypeEnv extra_env thing_inside + = tcGetEnv `thenNF_Tc` \ env -> + let + ge' = tcGEnv env `plusNameEnv` extra_env + in + tcSetEnv (env {tcGEnv = ge'}) thing_inside -tcExtendClassEnv :: [(Name, ([TcKind s], Class))] -> TcM s r -> TcM s r -tcExtendClassEnv bindings scope - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> +tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a +tcExtendGlobalValEnv ids thing_inside + = tcGetEnv `thenNF_Tc` \ env -> let - ce' = addListToUFM ce bindings + ge' = extendTypeEnvWithIds (tcGEnv env) ids in - tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope + tcSetEnv (env {tcGEnv = ge'}) thing_inside \end{code} -Looking up in the environments. +\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} -tcLookupTyVar name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM tve (pprPanic "tcLookupTyVar:" (ppr name)) name) +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 id) -> 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 - = -- Try for a wired-in tycon - case maybeWiredInTyConName name of { - Just tc | isSynTyCon tc -> returnTc (kind, Just (tyConArity tc), tc) - | otherwise -> returnTc (kind, Nothing, tc) - where { - kind = kindToTcKind (tyConKind tc) - }; - - Nothing -> - - -- Try in the environment - tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - case lookupUFM tce name of { - Just stuff -> returnTc stuff; - - Nothing -> - - -- Could be that he's using a class name as a type constructor - case lookupUFM ce name of - Just _ -> failWithTc (classAsTyConErr name) - Nothing -> pprPanic "tcLookupTyCon:" (ppr name) - } } - -tcLookupTyConByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce - (pprPanic "tcLookupTyConByKey:" (pprUnique10 uniq)) - uniq - in - returnNF_Tc tycon + = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_tc -> + case maybe_tc of + Just (ATyCon tc) -> returnNF_Tc tc + other -> notFound "tcLookupTyCon" name + +tcLookupId :: Name -> NF_TcM Id +tcLookupId name + = tcLookup name `thenNF_Tc` \ thing -> + case thing of + ATcId tc_id -> returnNF_Tc tc_id + AGlobal (AnId id) -> returnNF_Tc id + other -> pprPanic "tcLookupId" (ppr name) + +tcLookupLocalIds :: [Name] -> NF_TcM [TcId] +tcLookupLocalIds ns + = tcGetEnv `thenNF_Tc` \ env -> + returnNF_Tc (map (lookup (tcLEnv env)) ns) + where + lookup lenv name = case lookupNameEnv lenv name of + Just (ATcId id) -> id + other -> pprPanic "tcLookupLocalIds" (ppr name) +\end{code} -tcLookupClass name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - case lookupUFM ce name of - Just stuff -- Common case: it's ok - -> returnTc stuff - Nothing -- Could be that he's using a type constructor as a class - | maybeToBool (maybeWiredInTyConName name) - || maybeToBool (lookupUFM tce name) - -> failWithTc (tyConAsClassErr name) +%************************************************************************ +%* * +\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} - | otherwise -- Wierd! Renamer shouldn't let this happen - -> pprPanic "tcLookupClass" (ppr name) -tcLookupClassByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> +\begin{code} +tcExtendKindEnv :: [(Name,TcKind)] -> TcM r -> TcM r +tcExtendKindEnv pairs thing_inside + = tcGetEnv `thenNF_Tc` \ env -> let - (kind, clas) = lookupWithDefaultUFM_Directly ce - (pprPanic "tcLookupClassByKey:" (pprUnique10 uniq)) - uniq + le' = extendNameEnvList (tcLEnv env) [(n, AThing k) | (n,k) <- pairs] + -- No need to extend global tyvars for kind checking in - returnNF_Tc clas - -tcGetTyConsAndClasses :: NF_TcM s ([TyCon], [Class]) -tcGetTyConsAndClasses - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc ([tc | (_, _, tc) <- eltsUFM tce], - [c | (_, c) <- eltsUFM 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 + 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 + -- 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 tce ce gve lve gtvs) -> +tcExtendLocalValEnv :: [(Name,TcId)] -> TcM a -> TcM a +tcExtendLocalValEnv names_w_ids thing_inside + = tcGetEnv `thenNF_Tc` \ env -> let - gve' = addListToUFM_Directly gve [(uniqueOf 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 tce ce gve' lve gtvs) 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 tce ce gve lve gtvs) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - let - lve' = addListToUFM lve (zipEqual "tcExtendLocalValEnv" names 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 tce ce gve lve' gtvs') 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. @@ -281,145 +467,75 @@ To improve subsequent calls to the same function it writes the zonked set back i the environment. \begin{code} -tcGetGlobalTyVars :: NF_TcM s (TcTyVarSet s) +tcGetGlobalTyVars :: NF_TcM TcTyVarSet tcGetGlobalTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - zonkTcTyVars global_tvs `thenNF_Tc` \ global_tvs' -> - tcWriteMutVar gtvs global_tvs' `thenNF_Tc_` - returnNF_Tc global_tvs' - -tcExtendGlobalTyVars extra_global_tvs scope - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - let - new_global_tyvars = global_tvs `unionTyVarSets` mkTyVarSet extra_global_tvs - in - tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' -> - tcSetEnv (TcEnv tve tce ce gve lve gtvs') scope + = tcGetEnv `thenNF_Tc` \ (TcEnv {tcTyVars = gtv_var}) -> + tcReadMutVar gtv_var `thenNF_Tc` \ gbl_tvs -> + zonkTcTyVarsAndFV (varSetElems gbl_tvs) `thenNF_Tc` \ gbl_tvs' -> + tcWriteMutVar gtv_var gbl_tvs' `thenNF_Tc_` + returnNF_Tc gbl_tvs' \end{code} -\begin{code} -tcLookupLocalValue :: Name -> NF_TcM s (Maybe (TcIdBndr s)) -tcLookupLocalValue name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupUFM lve name) - -tcLookupLocalValueByKey :: Unique -> NF_TcM s (Maybe (TcIdBndr s)) -tcLookupLocalValueByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupUFM_Directly lve uniq) - -tcLookupLocalValueOK :: String -> Name -> NF_TcM s (TcIdBndr s) -tcLookupLocalValueOK err name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM lve (panic err) name) - - -tcLookupGlobalValue :: Name -> NF_TcM s Id -tcLookupGlobalValue name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc id - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM gve def name) - where - def = pprPanic "tcLookupGlobalValue:" (ppr name) - -tcLookupGlobalValueMaybe :: Name -> NF_TcM s (Maybe Id) -tcLookupGlobalValueMaybe name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc (Just id) - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupUFM gve name) - -tcLookupGlobalValueByKey :: Unique -> NF_TcM s Id -tcLookupGlobalValueByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM_Directly gve def uniq) - where -#ifdef DEBUG - def = pprPanic "tcLookupGlobalValueByKey:" (pprUnique10 uniq) -#else - def = panic "tcLookupGlobalValueByKey" -#endif +%************************************************************************ +%* * +\subsection{The instance environment} +%* * +%************************************************************************ -tcLookupGlobalValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id) -tcLookupGlobalValueByKeyMaybe uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupUFM_Directly gve uniq) +\begin{code} +tcGetInstEnv :: NF_TcM InstEnv +tcGetInstEnv = tcGetEnv `thenNF_Tc` \ env -> + returnNF_Tc (tcInsts env) +tcSetInstEnv :: InstEnv -> TcM a -> TcM a +tcSetInstEnv ie thing_inside + = tcGetEnv `thenNF_Tc` \ env -> + tcSetEnv (env {tcInsts = ie}) thing_inside +\end{code} --- Non-monadic version, environment given explicitly -tcExplicitLookupGlobal :: TcEnv s -> Name -> Maybe Id -tcExplicitLookupGlobal (TcEnv tve tce ce gve lve gtvs) name - = case maybeWiredInIdName name of - Just id -> Just id - Nothing -> lookupUFM gve name - -- Extract the IdInfo from an IfaceSig imported from an interface file -tcAddImportedIdInfo :: TcEnv s -> 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 `replaceIdInfo` new_info - -- The Id must be returned without a data dependency on maybe_id - where - new_info = -- pprTrace "tcAdd" (ppr id) $ - case tcExplicitLookupGlobal unf_env (getName id) of - Nothing -> noIdInfo - Just imported_id -> idInfo imported_id - -- ToDo: could check that types are the same -\end{code} +%************************************************************************ +%* * +\subsection{The InstInfo type} +%* * +%************************************************************************ +The InstInfo type summarises the information in an instance declaration -Constructing new Ids -~~~~~~~~~~~~~~~~~~~~ + instance c => k (t tvs) where b \begin{code} --- Uses the Name as the Name of the Id -newMonoIds :: [Name] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a - -newMonoIds names kind m - = newTyVarTys no_of_names kind `thenNF_Tc` \ tys -> - let - new_ids = zipWithEqual "newMonoIds" mk_id names tys - mk_id name ty = mkUserId name ty - in - tcExtendLocalValEnv names new_ids (m new_ids) - where - no_of_names = length names - -newLocalId :: OccName -> TcType s -> NF_TcM s (TcIdBndr s) -newLocalId name ty - = tcGetSrcLoc `thenNF_Tc` \ loc -> - tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkUserLocal name uniq ty loc) - -newLocalIds :: [OccName] -> [TcType s] -> NF_TcM s [TcIdBndr s] -newLocalIds names tys - = tcGetSrcLoc `thenNF_Tc` \ loc -> - 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 loc - in - returnNF_Tc new_ids - -newSpecPragmaId :: Name -> TcType s -> NF_TcM s (TcIdBndr s) -newSpecPragmaId name ty - = tcGetSrcLoc `thenNF_Tc` \ loc -> - tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty loc) +data InstInfo + = InstInfo { + iDFunId :: DFunId, -- The dfun id + iBinds :: RenamedMonoBinds, -- Bindings, b + iPrags :: [RenamedSig] -- User pragmas recorded for generating specialised instances + } + +pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info)), + nest 4 (ppr (iBinds info))] + +simpleInstInfoTy :: InstInfo -> Type +simpleInstInfoTy info = case tcSplitDFunTy (idType (iDFunId info)) of + (_, _, _, [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 = tcTyConAppTyCon (simpleInstInfoTy inst) \end{code} +%************************************************************************ +%* * +\subsection{Errors} +%* * +%************************************************************************ + \begin{code} -classAsTyConErr name - = ptext SLIT("Class used as a type constructor:") <+> ppr name +badCon con_id = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor") -tyConAsClassErr name - = ptext SLIT("Type constructor used as a class:") <+> ppr name +notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+> + ptext SLIT("is not in scope")) \end{code}