X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=5360887b786fd55c40360b095a585a6e225c8317;hb=16e4ce4c0c02650082f2e11982017c903c549ad5;hp=1f83155b6e5de03392d6ad993fd930b5aa435b9e;hpb=c7e7bc25c21e28651194d9d37a53a8820932fba7;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 1f83155..5360887 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,237 +1,203 @@ \begin{code} module TcEnv( - TcId, TcIdSet, - TyThing(..), TyThingDetails(..), TcTyThing(..), + TyThing(..), TyThingDetails(..), TcTyThing(..), TcId, - -- Getting stuff from the environment - TcEnv, initTcEnv, - tcEnvTyCons, tcEnvClasses, tcEnvIds, tcEnvTcIds, tcEnvTyVars, - getTcGEnv, - -- Instance environment, and InstInfo type - tcGetInstEnv, tcSetInstEnv, - InstInfo(..), pprInstInfo, + tcGetInstEnv, + InstInfo(..), pprInstInfo, pprInstInfoDetails, simpleInstInfoTy, simpleInstInfoTyCon, + InstBindings(..), -- Global environment - tcExtendGlobalEnv, tcExtendGlobalValEnv, tcExtendGlobalTypeEnv, - tcLookupTyCon, tcLookupClass, tcLookupGlobalId, tcLookupDataCon, - tcLookupGlobal_maybe, tcLookupGlobal, tcLookupSyntaxId, tcLookupSyntaxName, + tcExtendGlobalEnv, + tcExtendGlobalValEnv, + tcExtendGlobalTypeEnv, + tcLookupTyCon, tcLookupClass, tcLookupDataCon, + tcLookupGlobal_maybe, tcLookupGlobal, tcLookupGlobalId, + getInGlobalScope, -- Local environment - tcExtendKindEnv, tcLookupLocalIds, tcInLocalScope, - tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, - tcExtendLocalValEnv, tcLookup, tcLookup_maybe, tcLookupId, + tcExtendKindEnv, + tcExtendTyVarEnv, tcExtendTyVarEnv2, + tcExtendLocalValEnv, tcExtendLocalValEnv2, + tcLookup, tcLookupLocalIds, tcLookup_maybe, + tcLookupId, + lclEnvElts, getInLocalScope, findGlobals, + + -- Instance environment + tcExtendLocalInstEnv, tcExtendInstEnv, tcExtendTempInstEnv, tcWithTempInstEnv, + + -- Rules + tcExtendRules, -- Global type variables - tcGetGlobalTyVars, tcExtendGlobalTyVars, + tcGetGlobalTyVars, - -- Random useful things - RecTcEnv, tcAddImportedIdInfo, tcLookupRecId, tcLookupRecId_maybe, + -- Template Haskell stuff + checkWellStaged, spliceOK, bracketOK, tcMetaTy, thLevel, + topIdLvl, + + -- Arrow stuff + checkProcLevel, -- New Ids - newLocalId, newSpecPragmaId, - newDFunName, + newLocalName, newDFunName, -- Misc - isLocalThing, tcSetEnv + isLocalThing ) where #include "HsVersions.h" import RnHsSyn ( RenamedMonoBinds, RenamedSig ) -import TcMonad -import TcType ( TcKind, TcType, TcTyVar, TcTyVarSet, - zonkTcTyVarsAndFV +import HsSyn ( RuleDecl(..), ifaceRuleDeclName ) +import TcRnMonad +import TcMType ( zonkTcType, zonkTcTyVar, zonkTcTyVarsAndFV ) +import TcType ( Type, ThetaType, TcKind, TcTyVar, TcTyVarSet, + tyVarsOfType, tyVarsOfTypes, tcSplitDFunTy, mkGenTyConApp, + getDFunTyKey, tcTyConAppTyCon, tyVarBindingInfo, + tidyOpenType, tidyOpenTyVar ) -import Id ( idName, mkSpecPragmaId, mkUserLocal, isDataConWrapId_maybe ) -import IdInfo ( vanillaIdInfo ) -import Var ( TyVar, Id, idType, lazySetIdInfo, idInfo ) +import qualified Type ( getTyVar_maybe ) +import Rules ( extendRuleBase ) +import Id ( idName, isLocalId ) +import Var ( TyVar, Id, idType ) import VarSet -import Type ( Type, ThetaType, - tyVarsOfTypes, splitDFunTy, - getDFunTyKey, tyConAppTyCon - ) +import VarEnv +import CoreSyn ( IdCoreRule ) import DataCon ( DataCon ) -import TyCon ( TyCon ) +import TyCon ( TyCon, DataConDetails ) import Class ( Class, ClassOpItem ) -import Name ( Name, OccName, NamedThing(..), - nameOccName, getSrcLoc, mkLocalName, isLocalName, - nameIsLocalOrFrom +import Name ( Name, NamedThing(..), + getSrcLoc, mkInternalName, nameIsLocalOrFrom ) -import NameEnv ( NameEnv, lookupNameEnv, nameEnvElts, elemNameEnv, - extendNameEnvList, emptyNameEnv, plusNameEnv ) +import NameEnv import OccName ( mkDFunOcc, occNameString ) -import HscTypes ( DFunId, - PackageTypeEnv, TypeEnv, - extendTypeEnvList, extendTypeEnvWithIds, - typeEnvTyCons, typeEnvClasses, typeEnvIds, - HomeSymbolTable - ) +import HscTypes ( DFunId, TypeEnv, extendTypeEnvList, lookupType, + TyThing(..), ExternalPackageState(..) ) +import Rules ( RuleBase ) +import BasicTypes ( EP ) import Module ( Module ) -import InstEnv ( InstEnv, emptyInstEnv ) -import HscTypes ( lookupType, TyThing(..) ) -import Util ( zipEqual ) +import InstEnv ( InstEnv, extendInstEnv ) import SrcLoc ( SrcLoc ) -import qualified PrelNames import Outputable - -import IOExts ( newIORef ) +import Maybe ( isJust ) +import List ( partition ) \end{code} + %************************************************************************ %* * -\subsection{TcEnv} + Arrow notation proc levels %* * %************************************************************************ \begin{code} -type TcId = Id -- Type may be a TcType -type TcIdSet = IdSet - -data TcEnv - = TcEnv { - tcSyntaxMap :: PrelNames.SyntaxMap, -- The syntax map (usually the identity) - - 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 start in the local envt, - -- though they move to the global envt during zonking) - - 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 - } - +checkProcLevel :: TcId -> ProcLevel -> TcM () +checkProcLevel id id_lvl + = do { banned <- getBannedProcLevels + ; checkTc (not (id_lvl `elem` banned)) + (procLevelErr id id_lvl) } + +procLevelErr id id_lvl + = hang (ptext SLIT("Command-bound variable") <+> quotes (ppr id) <+> ptext SLIT("is not in scope here")) + 4 (ptext SLIT("Reason: it is used in the left argument of (-<)")) \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 - +%************************************************************************ +%* * + Meta level +%* * +%************************************************************************ \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 :: PrelNames.SyntaxMap -> HomeSymbolTable -> PackageTypeEnv -> IO TcEnv -initTcEnv syntax_map hst pte - = do { gtv_var <- newIORef emptyVarSet ; - return (TcEnv { tcSyntaxMap = syntax_map, - tcGST = lookup, - tcGEnv = emptyNameEnv, - tcInsts = emptyInstEnv, - tcLEnv = emptyNameEnv, - tcTyVars = gtv_var - })} +instance Outputable ThStage where + ppr Comp = text "Comp" + ppr (Brack l _ _) = text "Brack" <+> int l + ppr (Splice l) = text "Splice" <+> int l + + +thLevel :: ThStage -> ThLevel +thLevel Comp = topLevel +thLevel (Splice l) = l +thLevel (Brack l _ _) = l + + +checkWellStaged :: SDoc -- What the stage check is for + -> ThLevel -- Binding level + -> ThStage -- Use stage + -> TcM () -- Fail if badly staged, adding an error +checkWellStaged pp_thing bind_lvl use_stage + | bind_lvl <= use_lvl -- OK! + = returnM () + + | bind_lvl == topLevel -- GHC restriction on top level splices + = failWithTc $ + sep [ptext SLIT("GHC stage restriction:") <+> pp_thing, + nest 2 (ptext SLIT("is used in a top-level splice, and must be imported, not defined locally"))] + + | otherwise -- Badly staged + = failWithTc $ + ptext SLIT("Stage error:") <+> pp_thing <+> + hsep [ptext SLIT("is bound at stage") <+> ppr bind_lvl, + ptext SLIT("but used at stage") <+> ppr use_lvl] 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) -tcEnvTyVars env = [tv | ATyVar tv <- nameEnvElts (tcLEnv env)] -tcEnvTcIds env = [id | ATcId id <- nameEnvElts (tcLEnv env)] - -getTcGEnv (TcEnv { tcGEnv = genv }) = genv - -tcInLocalScope :: TcEnv -> Name -> Bool -tcInLocalScope env v = v `elemNameEnv` (tcLEnv env) - --- This data type is used to help tie the knot --- when type checking type and class declarations -data TyThingDetails = SynTyDetails Type - | DataTyDetails ThetaType [DataCon] [Id] - | ClassDetails ThetaType [Id] [ClassOpItem] DataCon + use_lvl = thLevel use_stage + + +topIdLvl :: Id -> ThLevel +-- Globals may either be imported, or may be from an earlier "chunk" +-- (separated by declaration splices) of this module. The former +-- *can* be used inside a top-level splice, but the latter cannot. +-- Hence we give the former impLevel, but the latter topLevel +-- E.g. this is bad: +-- x = [| foo |] +-- $( f x ) +-- By the time we are prcessing the $(f x), the binding for "x" +-- will be in the global env, not the local one. +topIdLvl id | isLocalId id = topLevel + | otherwise = impLevel + +-- Indicates the legal transitions on bracket( [| |] ). +bracketOK :: ThStage -> Maybe ThLevel +bracketOK (Brack _ _ _) = Nothing -- Bracket illegal inside a bracket +bracketOK stage = (Just (thLevel stage + 1)) + +-- Indicates the legal transitions on splice($). +spliceOK :: ThStage -> Maybe ThLevel +spliceOK (Splice _) = Nothing -- Splice illegal inside splice +spliceOK stage = Just (thLevel stage - 1) + +tcMetaTy :: Name -> TcM Type +-- Given the name of a Template Haskell data type, +-- return the type +-- E.g. given the name "Expr" return the type "Expr" +tcMetaTy tc_name + = tcLookupTyCon tc_name `thenM` \ t -> + returnM (mkGenTyConApp t []) + -- Use mkGenTyConApp because it might be a synonym \end{code} %************************************************************************ %* * -\subsection{Basic lookups} +\subsection{TyThingDetails} %* * %************************************************************************ -\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} +This data type is used to help tie the knot + when type checking type and class declarations \begin{code} -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) +data TyThingDetails = SynTyDetails Type + | DataTyDetails ThetaType (DataConDetails DataCon) [Id] (Maybe (EP Id)) + | ClassDetails ThetaType [Id] [ClassOpItem] DataCon Name + -- The Name is the Name of the implicit TyCon for the class + | ForeignTyDetails -- Nothing yet \end{code} + %************************************************************************ %* * \subsection{Making new Ids} @@ -241,26 +207,23 @@ tcLookupRecId env name = case lookup_global env name of 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)) +newLocalName :: Name -> TcM Name +newLocalName name -- Make a clone + = newUnique `thenM` \ uniq -> + returnM (mkInternalName uniq (getOccName name) (getSrcLoc name)) \end{code} -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. +Make a name for the dict fun for an instance decl. It's a *local* +name for the moment. The CoreTidy pass will externalise it. Even in +--make and ghci stuff, we rebuild the instance environment each time, +so the dfun id is internal to begin with, and external when compiling +other modules \begin{code} -newDFunName :: Class -> [Type] -> SrcLoc -> NF_TcM Name +newDFunName :: Class -> [Type] -> SrcLoc -> TcM Name newDFunName clas (ty:_) loc - = tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkLocalName uniq (mkDFunOcc dfun_string) loc) + = newUnique `thenM` \ uniq -> + returnM (mkInternalName uniq (mkDFunOcc dfun_string) loc) where -- Any string that is somewhat unique will do dfun_string = occNameString (getOccName clas) ++ occNameString (getDFunTyKey ty) @@ -281,109 +244,104 @@ isLocalThing mod thing = nameIsLocalOrFrom mod (getName thing) \begin{code} tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r + -- Given a mixture of Ids, TyCons, Classes, perhaps from the + -- module being compiled, perhaps from a package module, + -- extend the global environment, and update the EPS tcExtendGlobalEnv things thing_inside - = tcGetEnv `thenNF_Tc` \ env -> - let - ge' = extendTypeEnvList (tcGEnv env) things - in - tcSetEnv (env {tcGEnv = ge'}) thing_inside + = do { eps <- getEps + ; hpt <- getHpt + ; env <- getGblEnv + ; let mod = tcg_mod env + (lcl_things, pkg_things) = partition (isLocalThing mod) things + ge' = extendTypeEnvList (tcg_type_env env) lcl_things + eps' = eps { eps_PTE = extendTypeEnvList (eps_PTE eps) pkg_things } + ; setEps eps' + ; setGblEnv (env {tcg_type_env = ge'}) thing_inside } +tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a + -- Same deal as tcExtendGlobalEnv, but for Ids +tcExtendGlobalValEnv ids thing_inside + = tcExtendGlobalEnv [AnId id | id <- ids] thing_inside tcExtendGlobalTypeEnv :: TypeEnv -> TcM r -> TcM r + -- Top-level things of the interactive context + -- No need to extend the package env tcExtendGlobalTypeEnv extra_env thing_inside - = tcGetEnv `thenNF_Tc` \ env -> - let - ge' = tcGEnv env `plusNameEnv` extra_env - in - tcSetEnv (env {tcGEnv = ge'}) thing_inside - -tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a -tcExtendGlobalValEnv ids thing_inside - = tcGetEnv `thenNF_Tc` \ env -> - let - ge' = extendTypeEnvWithIds (tcGEnv env) ids - in - tcSetEnv (env {tcGEnv = ge'}) thing_inside + = do { env <- getGblEnv + ; let ge' = tcg_type_env env `plusNameEnv` extra_env + ; setGblEnv (env {tcg_type_env = ge'}) thing_inside } \end{code} \begin{code} -tcLookupGlobal_maybe :: Name -> NF_TcM (Maybe TyThing) +tcLookupGlobal_maybe :: Name -> TcRn m (Maybe TyThing) +-- This is a rather heavily-used function, so I've inlined a few things (e.g. getEps) +-- Notice that for imported things we read the current version from the EPS +-- mutable variable. This is important in situations like +-- ...$(e1)...$(e2)... +-- where the code that e1 expands to might import some defns that +-- also turn out to be needed by the code that e2 expands to. tcLookupGlobal_maybe name - = tcGetEnv `thenNF_Tc` \ env -> - returnNF_Tc (lookup_global env name) + = do { env <- getGblEnv + ; if nameIsLocalOrFrom (tcg_mod env) name then + -- Defined in this module + return (lookupNameEnv (tcg_type_env env) name) + else + do { env <- getTopEnv + ; eps <- readMutVar (top_eps env) + ; return (lookupType (top_hpt env) (eps_PTE eps) 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 -> TcM TyThing tcLookupGlobal name - = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_thing -> + = tcLookupGlobal_maybe name `thenM` \ maybe_thing -> case maybe_thing of - Just thing -> returnNF_Tc thing + Just thing -> returnM thing other -> notFound "tcLookupGlobal" name -tcLookupGlobalId :: Name -> NF_TcM Id +tcLookupGlobalId :: Name -> TcM Id +-- Never used for Haskell-source DataCons, hence no ADataCon case tcLookupGlobalId name - = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_id -> - case maybe_id of - Just (AnId id) -> returnNF_Tc id - other -> notFound "tcLookupGlobalId" name - + = tcLookupGlobal_maybe name `thenM` \ maybe_thing -> + case maybe_thing of + Just (AnId id) -> returnM id + other -> notFound "tcLookupGlobal (id)" 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) - + = tcLookupGlobal_maybe con_name `thenM` \ maybe_thing -> + case maybe_thing of + Just (ADataCon data_con) -> returnM data_con + other -> notFound "tcLookupDataCon" con_name -tcLookupClass :: Name -> NF_TcM Class +tcLookupClass :: Name -> TcM Class tcLookupClass name - = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_clas -> + = tcLookupGlobal_maybe name `thenM` \ maybe_clas -> case maybe_clas of - Just (AClass clas) -> returnNF_Tc clas + Just (AClass clas) -> returnM clas other -> notFound "tcLookupClass" name -tcLookupTyCon :: Name -> NF_TcM TyCon +tcLookupTyCon :: Name -> TcM TyCon tcLookupTyCon name - = tcLookupGlobal_maybe name `thenNF_Tc` \ maybe_tc -> + = tcLookupGlobal_maybe name `thenM` \ maybe_tc -> case maybe_tc of - Just (ATyCon tc) -> returnNF_Tc tc + Just (ATyCon tc) -> returnM 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) - -tcLookupSyntaxId :: Name -> NF_TcM Id --- Lookup a name like PrelNum.fromInt, and return the corresponding Id, --- after mapping through the SyntaxMap. This may give us the Id for --- (say) MyPrelude.fromInteger -tcLookupSyntaxId name - = tcGetEnv `thenNF_Tc` \ env -> - returnNF_Tc (case lookup_global env (tcSyntaxMap env name) of - Just (AnId id) -> id - other -> pprPanic "tcLookupSyntaxId" (ppr name)) - -tcLookupSyntaxName :: Name -> NF_TcM Name -tcLookupSyntaxName name - = tcGetEnv `thenNF_Tc` \ env -> - returnNF_Tc (tcSyntaxMap env name) +getInGlobalScope :: TcRn m (Name -> Bool) +-- Get all things in the global environment; used for deciding what +-- rules to suck in. Anything defined in this module (nameIsLocalOrFrom) +-- is certainly in the envt, so we don't bother to look. +getInGlobalScope + = do { mod <- getModule + ; eps <- getEps + ; hpt <- getHpt + ; return (\n -> nameIsLocalOrFrom mod n || + isJust (lookupType hpt (eps_PTE eps) n)) } \end{code} @@ -394,36 +352,81 @@ tcLookupSyntaxName name %************************************************************************ \begin{code} -tcLookup_maybe :: Name -> NF_TcM (Maybe TcTyThing) +tcLookup_maybe :: Name -> TcM (Maybe TcTyThing) tcLookup_maybe name - = tcGetEnv `thenNF_Tc` \ env -> - returnNF_Tc (lookup_local env name) - -tcLookup :: Name -> NF_TcM TcTyThing + = getLclEnv `thenM` \ local_env -> + case lookupNameEnv (tcl_env local_env) name of + Just thing -> returnM (Just thing) + Nothing -> tcLookupGlobal_maybe name `thenM` \ mb_res -> + returnM (case mb_res of + Just thing -> Just (AGlobal thing) + Nothing -> Nothing) + +tcLookup :: Name -> TcM TcTyThing tcLookup name - = tcLookup_maybe name `thenNF_Tc` \ maybe_thing -> + = tcLookup_maybe name `thenM` \ maybe_thing -> case maybe_thing of - Just thing -> returnNF_Tc thing + Just thing -> returnM thing other -> notFound "tcLookup" name -- Extract the IdInfo from an IfaceSig imported from an interface file -\end{code} +tcLookupId :: Name -> TcM Id +-- Used when we aren't interested in the binding level +-- Never a DataCon. (Why does that matter? see TcExpr.tcId) +tcLookupId name + = tcLookup name `thenM` \ thing -> + case thing of + ATcId tc_id _ _ -> returnM tc_id + AGlobal (AnId id) -> returnM id + other -> pprPanic "tcLookupId" (ppr name) + +tcLookupLocalIds :: [Name] -> TcM [TcId] +-- We expect the variables to all be bound, and all at +-- the same level as the lookup. Only used in one place... +tcLookupLocalIds ns + = getLclEnv `thenM` \ env -> + returnM (map (lookup (tcl_env env) (thLevel (tcl_th_ctxt env))) ns) + where + lookup lenv lvl name + = case lookupNameEnv lenv name of + Just (ATcId id lvl1 _) -> ASSERT( lvl == lvl1 ) id + other -> pprPanic "tcLookupLocalIds" (ppr name) + +lclEnvElts :: TcLclEnv -> [TcTyThing] +lclEnvElts env = nameEnvElts (tcl_env env) + +getInLocalScope :: TcM (Name -> Bool) + -- Ids only +getInLocalScope = getLclEnv `thenM` \ env -> + let + lcl_env = tcl_env env + in + return (`elemNameEnv` lcl_env) +\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] + = updLclEnv upd thing_inside + where + upd lcl_env = lcl_env { tcl_env = extend (tcl_env lcl_env) } + extend env = extendNameEnvList 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}) -> +tcExtendTyVarEnv tvs thing_inside + = tc_extend_tv_env [(getName tv, ATyVar tv) | tv <- tvs] tvs thing_inside + +tcExtendTyVarEnv2 :: [(TyVar,TcTyVar)] -> TcM r -> TcM r +tcExtendTyVarEnv2 tv_pairs thing_inside + = tc_extend_tv_env [(getName tv1, ATyVar tv2) | (tv1,tv2) <- tv_pairs] + [tv | (_,tv) <- tv_pairs] + thing_inside + +tc_extend_tv_env binds tyvars thing_inside + = getLclEnv `thenM` \ env@(TcLclEnv {tcl_env = le, tcl_tyvars = gtvs}) -> let - le' = extendNameEnvList le [ (getName tv, ATyVar tv) | tv <- tyvars] + le' = extendNameEnvList le binds new_tv_set = mkVarSet tyvars in -- It's important to add the in-scope tyvars to the global tyvar set @@ -432,39 +435,93 @@ tcExtendTyVarEnv tyvars thing_inside -- 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 + tc_extend_gtvs gtvs new_tv_set `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs'}) thing_inside \end{code} \begin{code} -tcExtendLocalValEnv :: [(Name,TcId)] -> TcM a -> TcM a -tcExtendLocalValEnv names_w_ids thing_inside - = tcGetEnv `thenNF_Tc` \ env -> +tcExtendLocalValEnv :: [TcId] -> TcM a -> TcM a +tcExtendLocalValEnv ids thing_inside + = getLclEnv `thenM` \ env -> + let + extra_global_tyvars = tyVarsOfTypes [idType id | id <- ids] + th_lvl = thLevel (tcl_th_ctxt env) + proc_lvl = proc_level (tcl_arrow_ctxt env) + extra_env = [(idName id, ATcId id th_lvl proc_lvl) | id <- ids] + le' = extendNameEnvList (tcl_env env) extra_env + in + tc_extend_gtvs (tcl_tyvars env) extra_global_tyvars `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs'}) thing_inside + +tcExtendLocalValEnv2 :: [(Name,TcId)] -> TcM a -> TcM a +tcExtendLocalValEnv2 names_w_ids thing_inside + = getLclEnv `thenM` \ env -> let 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 + th_lvl = thLevel (tcl_th_ctxt env) + proc_lvl = proc_level (tcl_arrow_ctxt env) + extra_env = [(name, ATcId id th_lvl proc_lvl) | (name,id) <- names_w_ids] + le' = extendNameEnvList (tcl_env env) extra_env in - tc_extend_gtvs (tcTyVars env) extra_global_tyvars `thenNF_Tc` \ gtvs' -> - tcSetEnv (env {tcLEnv = le', tcTyVars = gtvs'}) thing_inside + tc_extend_gtvs (tcl_tyvars env) extra_global_tyvars `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs'}) thing_inside +\end{code} + + +\begin{code} +----------------------- +-- findGlobals looks at the value environment and finds values +-- whose types mention the offending type variable. It has to be +-- careful to zonk the Id's type first, so it has to be in the monad. +-- We must be careful to pass it a zonked type variable, too. + +findGlobals :: TcTyVarSet + -> TidyEnv + -> TcM (TidyEnv, [SDoc]) + +findGlobals tvs tidy_env + = getLclEnv `thenM` \ lcl_env -> + go tidy_env [] (lclEnvElts lcl_env) + where + go tidy_env acc [] = returnM (tidy_env, acc) + go tidy_env acc (thing : things) + = find_thing ignore_it tidy_env thing `thenM` \ (tidy_env1, maybe_doc) -> + case maybe_doc of + Just d -> go tidy_env1 (d:acc) things + Nothing -> go tidy_env1 acc things + + ignore_it ty = not (tvs `intersectsVarSet` tyVarsOfType ty) + +----------------------- +find_thing ignore_it tidy_env (ATcId id _ _) + = zonkTcType (idType id) `thenM` \ id_ty -> + if ignore_it id_ty then + returnM (tidy_env, Nothing) + else let + (tidy_env', tidy_ty) = tidyOpenType tidy_env id_ty + msg = sep [ppr id <+> dcolon <+> ppr tidy_ty, + nest 2 (parens (ptext SLIT("bound at") <+> + ppr (getSrcLoc id)))] + in + returnM (tidy_env', Just msg) + +find_thing ignore_it tidy_env (ATyVar tv) + = zonkTcTyVar tv `thenM` \ tv_ty -> + if ignore_it tv_ty then + returnM (tidy_env, Nothing) + else let + (tidy_env1, tv1) = tidyOpenTyVar tidy_env tv + (tidy_env2, tidy_ty) = tidyOpenType tidy_env1 tv_ty + msg = sep [ppr tv1 <+> eq_stuff, nest 2 bound_at] + + eq_stuff | Just tv' <- Type.getTyVar_maybe tv_ty, tv == tv' = empty + | otherwise = equals <+> ppr tv_ty + -- It's ok to use Type.getTyVar_maybe because ty is zonked by now + + bound_at = tyVarBindingInfo tv + in + returnM (tidy_env2, Just msg) \end{code} @@ -475,14 +532,9 @@ tcExtendLocalValEnv names_w_ids thing_inside %************************************************************************ \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) + = readMutVar gtvs `thenM` \ global_tvs -> + newMutVar (global_tvs `unionVarSet` extra_global_tvs) \end{code} @tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment. @@ -490,13 +542,13 @@ To improve subsequent calls to the same function it writes the zonked set back i the environment. \begin{code} -tcGetGlobalTyVars :: NF_TcM TcTyVarSet +tcGetGlobalTyVars :: TcM TcTyVarSet tcGetGlobalTyVars - = 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' + = getLclEnv `thenM` \ (TcLclEnv {tcl_tyvars = gtv_var}) -> + readMutVar gtv_var `thenM` \ gbl_tvs -> + zonkTcTyVarsAndFV (varSetElems gbl_tvs) `thenM` \ gbl_tvs' -> + writeMutVar gtv_var gbl_tvs' `thenM_` + returnM gbl_tvs' \end{code} @@ -506,16 +558,129 @@ tcGetGlobalTyVars %* * %************************************************************************ +The TcGblEnv holds a mutable variable containing the current full, instance environment. +The ExtendInstEnv functions extend this environment by side effect, in case we are +sucking in new instance declarations deep in the body of a TH splice, which are needed +in another TH splice. The tcg_insts field of the TcGblEnv contains just the dfuns +from this module + \begin{code} -tcGetInstEnv :: NF_TcM InstEnv -tcGetInstEnv = tcGetEnv `thenNF_Tc` \ env -> - returnNF_Tc (tcInsts env) +tcGetInstEnv :: TcM InstEnv +tcGetInstEnv = do { env <- getGblEnv; readMutVar (tcg_inst_env env) } + +tcExtendInstEnv :: [DFunId] -> TcM a -> TcM a + -- Add instances from local or imported + -- instances, and refresh the instance-env cache +tcExtendInstEnv dfuns thing_inside + = do { dflags <- getDOpts + ; eps <- getEps + ; env <- getGblEnv + ; let ie_var = tcg_inst_env env + ; inst_env <- readMutVar ie_var + ; let + -- Extend the total inst-env with the new dfuns + (inst_env', errs) = extendInstEnv dflags inst_env dfuns + + -- Sort the ones from this module from the others + (lcl_dfuns, pkg_dfuns) = partition (isLocalThing mod) dfuns + mod = tcg_mod env + + -- And add the pieces to the right places + (eps_inst_env', _) = extendInstEnv dflags (eps_inst_env eps) pkg_dfuns + eps' = eps { eps_inst_env = eps_inst_env' } + + env' = env { tcg_insts = lcl_dfuns ++ tcg_insts env } + + ; traceDFuns dfuns + ; addErrs errs + ; writeMutVar ie_var inst_env' + ; setEps eps' + ; setGblEnv env' thing_inside } + +tcExtendLocalInstEnv :: [InstInfo] -> TcM a -> TcM a + -- Special case for local instance decls +tcExtendLocalInstEnv infos thing_inside + = do { dflags <- getDOpts + ; env <- getGblEnv + ; let ie_var = tcg_inst_env env + ; inst_env <- readMutVar ie_var + ; let + dfuns = map iDFunId infos + (inst_env', errs) = extendInstEnv dflags inst_env dfuns + env' = env { tcg_insts = dfuns ++ tcg_insts env } + ; traceDFuns dfuns + ; addErrs errs + ; writeMutVar ie_var inst_env' + ; setGblEnv env' thing_inside } + +tcExtendTempInstEnv :: [DFunId] -> TcM a -> TcM a + -- Extend the instance envt, but with *no* permanent + -- effect on mutable variables; also ignore errors + -- Used during 'deriving' stuff +tcExtendTempInstEnv dfuns thing_inside + = do { dflags <- getDOpts + ; env <- getGblEnv + ; let ie_var = tcg_inst_env env + ; inst_env <- readMutVar ie_var + ; let (inst_env', errs) = extendInstEnv dflags inst_env dfuns + -- Ignore the errors about duplicate instances. + -- We don't want repeated error messages + -- They'll appear later, when we do the top-level extendInstEnvs + ; writeMutVar ie_var inst_env' + ; result <- thing_inside + ; writeMutVar ie_var inst_env -- Restore! + ; return result } + +tcWithTempInstEnv :: TcM a -> TcM a +-- Run thing_inside, discarding any effects on the instance environment +tcWithTempInstEnv thing_inside + = do { env <- getGblEnv + ; let ie_var = tcg_inst_env env + ; old_ie <- readMutVar ie_var + ; result <- thing_inside + ; writeMutVar ie_var old_ie -- Restore + ; return result } + +traceDFuns dfuns + = traceTc (text "Adding instances:" <+> vcat (map pp dfuns)) + where + pp dfun = ppr dfun <+> dcolon <+> ppr (idType dfun) +\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{Rules} +%* * +%************************************************************************ + +\begin{code} +tcExtendRules :: [RuleDecl Id] -> TcM a -> TcM a + -- Just pop the new rules into the EPS and envt resp + -- All the rules come from an interface file, not soruce + -- Nevertheless, some may be for this module, if we read + -- its interface instead of its source code +tcExtendRules rules thing_inside + = do { eps <- getEps + ; env <- getGblEnv + ; let + (lcl_rules, pkg_rules) = partition is_local_rule rules + is_local_rule = isLocalThing mod . ifaceRuleDeclName + mod = tcg_mod env + + core_rules = [(id,rule) | IfaceRuleOut id rule <- pkg_rules] + eps' = eps { eps_rule_base = addIfaceRules (eps_rule_base eps) core_rules } + -- All the rules from an interface are of the IfaceRuleOut form + + env' = env { tcg_rules = lcl_rules ++ tcg_rules env } + + ; setEps eps' + ; setGblEnv env' thing_inside } + +addIfaceRules :: RuleBase -> [IdCoreRule] -> RuleBase +addIfaceRules rule_base rules + = foldl extendRuleBase rule_base rules +\end{code} %************************************************************************ @@ -528,25 +693,44 @@ The InstInfo type summarises the information in an instance declaration instance c => k (t tvs) where b +It is used just for *local* instance decls (not ones from interface files). +But local instance decls includes + - derived ones + - generic ones +as well as explicit user written ones. + \begin{code} data InstInfo = InstInfo { iDFunId :: DFunId, -- The dfun id - iBinds :: RenamedMonoBinds, -- Bindings, b - iPrags :: [RenamedSig] -- User pragmas recorded for generating specialised instances + iBinds :: InstBindings } -pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info)), - nest 4 (ppr (iBinds info))] +data InstBindings + = VanillaInst -- The normal case + RenamedMonoBinds -- Bindings + [RenamedSig] -- User pragmas recorded for generating + -- specialised instances + + | NewTypeDerived -- Used for deriving instances of newtypes, where the + [Type] -- witness dictionary is identical to the argument + -- dictionary. Hence no bindings, no pragmas + -- The [Type] are the representation types + -- See notes in TcDeriv + +pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info))] + +pprInstInfoDetails (InstInfo { iBinds = VanillaInst b _ }) = ppr b +pprInstInfoDetails (InstInfo { iBinds = NewTypeDerived _}) = text "Derived from the representation type" simpleInstInfoTy :: InstInfo -> Type -simpleInstInfoTy info = case splitDFunTy (idType (iDFunId info)) of +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 = tyConAppTyCon (simpleInstInfoTy inst) +simpleInstInfoTyCon inst = tcTyConAppTyCon (simpleInstInfoTy inst) \end{code}