X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=cb2eb28004c8da210c86f8ef180baa4685a92a88;hb=9ec3012e2fd5b998e32897c03551574038fd59a8;hp=b9b308bc4c37263fd205b147c291de2e57de6f59;hpb=69e14f75a4b031e489b7774914e5a176409cea78;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index b9b308b..cb2eb28 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,227 +1,402 @@ \begin{code} module TcEnv( - TcId, TcIdSet, tcInstId, - tcLookupDataCon, + TyThing(..), TcTyThing(..), TcId, + + -- Instance environment, and InstInfo type + InstInfo(..), pprInstInfo, pprInstInfoDetails, + simpleInstInfoTy, simpleInstInfoTyCon, + InstBindings(..), + + -- Global environment + tcExtendGlobalEnv, + tcExtendGlobalValEnv, + tcLookupLocatedGlobal, tcLookupGlobal, + tcLookupGlobalId, tcLookupTyCon, tcLookupClass, tcLookupDataCon, + tcLookupLocatedGlobalId, tcLookupLocatedTyCon, + tcLookupLocatedClass, tcLookupLocatedDataCon, + + getInGlobalScope, - TcEnv, ValueEnv, TcTyThing(..), + -- Local environment + tcExtendKindEnv, + tcExtendTyVarEnv, tcExtendTyVarEnv2, + tcExtendLocalValEnv, tcExtendLocalValEnv2, + tcLookup, tcLookupLocated, tcLookupLocalIds, + tcLookupId, tcLookupTyVar, + lclEnvElts, getInLocalScope, findGlobals, + wrongThingErr, - initEnv, getEnvTyCons, getEnvClasses, getAllEnvTyCons, - - tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars, + tcExtendRecEnv, -- For knot-tying - tcLookupTy, - tcLookupTyCon, tcLookupTyConByKey, - tcLookupClass, tcLookupClassByKey, + -- Rules + tcExtendRules, - tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcGetValueEnv, tcSetValueEnv, - tcAddImportedIdInfo, + -- Global type variables + tcGetGlobalTyVars, - tcLookupValue, tcLookupValueMaybe, - tcLookupValueByKey, tcLookupValueByKeyMaybe, - explicitLookupValueByKey, explicitLookupValue, + -- Template Haskell stuff + checkWellStaged, spliceOK, bracketOK, tcMetaTy, thLevel, + topIdLvl, - newLocalId, newSpecPragmaId, - tcGetGlobalTyVars, tcExtendGlobalTyVars, + -- Arrow stuff + checkProcLevel, - badCon, badPrimOp + -- New Ids + newLocalName, newDFunName ) 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, - splitForAllTys, splitRhoTy, splitFunTys, - splitAlgTyConApp_maybe, getTyVar - ) -import Subst ( substTy ) -import UsageSPUtils ( unannotTy ) -import DataCon ( DataCon ) -import TyCon ( TyCon, tyConKind, tyConArity, isSynTyCon ) -import Class ( Class, classTyCon ) - -import TcMonad - -import BasicTypes ( Arity ) -import IdInfo ( vanillaIdInfo ) -import Name ( Name, OccName, nameOccName, getSrcLoc, - maybeWiredInTyConName, maybeWiredInIdName, isLocallyDefined, - NamedThing(..) +import HsSyn ( LRuleDecl, LHsBinds, LSig, pprLHsBinds ) +import TcIface ( tcImportDecl ) +import TcRnMonad +import TcMType ( zonkTcType, zonkTcTyVar, zonkTcTyVarsAndFV ) +import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, + tyVarsOfType, tyVarsOfTypes, tcSplitDFunTy, mkGenTyConApp, + getDFunTyKey, tcTyConAppTyCon, tyVarBindingInfo, + tidyOpenType, tidyOpenTyVar ) -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, catMaybes ) -import SrcLoc ( SrcLoc ) -import FastString ( FastString ) +import qualified Type ( getTyVar_maybe ) +import Id ( idName, isLocalId ) +import Var ( TyVar, Id, idType ) +import VarSet +import VarEnv +import RdrName ( extendLocalRdrEnv ) +import DataCon ( DataCon ) +import TyCon ( TyCon ) +import Class ( Class ) +import Name ( Name, NamedThing(..), getSrcLoc, mkInternalName, nameIsLocalOrFrom ) +import NameEnv +import OccName ( mkDFunOcc, occNameString ) +import HscTypes ( DFunId, extendTypeEnvList, lookupType, + TyThing(..), tyThingId, tyThingDataCon, + ExternalPackageState(..) ) + +import SrcLoc ( SrcLoc, Located(..) ) import Outputable +import Maybe ( isJust ) \end{code} + %************************************************************************ %* * -\subsection{TcId} +%* tcLookupGlobal * %* * %************************************************************************ +Using the Located versions (eg. tcLookupLocatedGlobal) is preferred, +unless you know that the SrcSpan in the monad is already set to the +span of the Name. \begin{code} -type TcId = Id -- Type may be a TcType -type TcIdSet = IdSet +tcLookupLocatedGlobal :: Located Name -> TcM TyThing +-- c.f. IfaceEnvEnv.tcIfaceGlobal +tcLookupLocatedGlobal name + = addLocM tcLookupGlobal name + +tcLookupGlobal :: Name -> TcM TyThing +tcLookupGlobal name + = do { env <- getGblEnv + ; if nameIsLocalOrFrom (tcg_mod env) name + + then -- It's defined in this module + case lookupNameEnv (tcg_type_env env) name of + Just thing -> return thing + Nothing -> notFound "tcLookupGlobal" name + + else do -- It's imported + { eps <- getEps + ; hpt <- getHpt + ; case lookupType hpt (eps_PTE eps) name of + Just thing -> return thing + Nothing -> do { traceIf (text "tcLookupGlobal" <+> ppr name) + ; initIfaceTcRn (tcImportDecl name) } + }} +\end{code} + +\begin{code} +tcLookupGlobalId :: Name -> TcM Id +-- Never used for Haskell-source DataCons, hence no ADataCon case +tcLookupGlobalId name + = tcLookupGlobal name `thenM` \ thing -> + return (tyThingId thing) -tcLookupDataCon :: Name -> TcM s (DataCon, [TcType], TcType) +tcLookupDataCon :: Name -> TcM DataCon 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) } - --- 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 - TcThetaType, -- - TcType) -- -tcInstId id - = let - (tyvars, rho) = splitForAllTys (unannotTy (idType id)) - in - tcInstTyVars tyvars `thenNF_Tc` \ (tyvars', arg_tys, tenv) -> - let - rho' = substTy tenv rho - (theta', tau') = splitRhoTy rho' - in - returnNF_Tc (tyvars', theta', tau') -\end{code} + = tcLookupGlobal con_name `thenM` \ thing -> + return (tyThingDataCon thing) + +tcLookupClass :: Name -> TcM Class +tcLookupClass name + = tcLookupGlobal name `thenM` \ thing -> + case thing of + AClass cls -> return cls + other -> wrongThingErr "class" (AGlobal thing) name + +tcLookupTyCon :: Name -> TcM TyCon +tcLookupTyCon name + = tcLookupGlobal name `thenM` \ thing -> + case thing of + ATyCon tc -> return tc + other -> wrongThingErr "type constructor" (AGlobal thing) name + +tcLookupLocatedGlobalId :: Located Name -> TcM Id +tcLookupLocatedGlobalId = addLocM tcLookupId -Between the renamer and the first invocation of the UsageSP inference, -identifiers read from interface files will have usage information in -their types, whereas other identifiers will not. The unannotTy here -in @tcInstId@ prevents this information from pointlessly propagating -further prior to the first usage inference. +tcLookupLocatedDataCon :: Located Name -> TcM DataCon +tcLookupLocatedDataCon = addLocM tcLookupDataCon +tcLookupLocatedClass :: Located Name -> TcM Class +tcLookupLocatedClass = addLocM tcLookupClass + +tcLookupLocatedTyCon :: Located Name -> TcM TyCon +tcLookupLocatedTyCon = addLocM tcLookupTyCon +\end{code} %************************************************************************ %* * -\subsection{TcEnv} + Extending the global environment %* * %************************************************************************ -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ \begin{code} -data TcEnv = TcEnv - TypeEnv - ValueEnv - (TcTyVarSet, -- The in-scope TyVars - TcRef TcTyVarSet) -- Free type variables of the value env - -- ...why mutable? see notes with tcGetGlobalTyVars - -- Includes the in-scope tyvars - -type NameEnv val = UniqFM val -- Keyed by Names - -type TypeEnv = NameEnv (TcKind, Maybe Arity, TcTyThing) -type ValueEnv = NameEnv Id - -data TcTyThing = ATyVar TcTyVar -- Mutable only so that the kind can be mutable - -- if the kind is mutable, the tyvar must be so that - -- zonking works - | ATyCon TyCon - | AClass Class - - -initEnv :: TcRef TcTyVarSet -> TcEnv -initEnv mut = TcEnv emptyUFM emptyUFM (emptyVarSet, mut) - -getEnvTyCons (TcEnv te _ _) = [tc | (_, _, ATyCon tc) <- eltsUFM te] -getEnvClasses (TcEnv te _ _) = [cl | (_, _, AClass cl) <- eltsUFM te] -getAllEnvTyCons (TcEnv te _ _) = catMaybes (map gettc (eltsUFM te)) - where - gettc (_,_, ATyCon tc) = Just tc - gettc (_,_, AClass cl) = Just (classTyCon cl) - gettc _ = Nothing +tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r + -- Given a mixture of Ids, TyCons, Classes, all from the + -- module being compiled, extend the global environment +tcExtendGlobalEnv things thing_inside + = do { env <- getGblEnv + ; let ge' = extendTypeEnvList (tcg_type_env env) things + ; 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 \end{code} -The TypeEnv -~~~~~~~~~~~~ +A variety of global lookups, when we know what we are looking for. + +\begin{code} +getInGlobalScope :: TcM (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} -Extending the type environment. \begin{code} -tcExtendTyVarEnv :: [TyVar] -> TcM s r -> TcM s r -tcExtendTyVarEnv tyvars scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (in_scope_tvs, gtvs)) -> +tcExtendRecEnv :: [(Name,TyThing)] -> TcM r -> TcM r +-- Extend the global environments for the type/class knot tying game +tcExtendRecEnv gbl_stuff thing_inside + = updGblEnv upd thing_inside + where + upd env = env { tcg_type_env = extend (tcg_type_env env) } + extend env = extendNameEnvList env gbl_stuff +\end{code} + + +%************************************************************************ +%* * +\subsection{The local environment} +%* * +%************************************************************************ + +\begin{code} +tcLookupLocated :: Located Name -> TcM TcTyThing +tcLookupLocated = addLocM tcLookup + +tcLookup :: Name -> TcM TcTyThing +tcLookup name + = getLclEnv `thenM` \ local_env -> + case lookupNameEnv (tcl_env local_env) name of + Just thing -> returnM thing + Nothing -> tcLookupGlobal name `thenM` \ thing -> + returnM (AGlobal thing) + +tcLookupTyVar :: Name -> TcM Id +tcLookupTyVar name + = tcLookup name `thenM` \ thing -> + case thing of + ATyVar tv -> returnM tv + other -> pprPanic "tcLookupTyVar" (ppr name) + +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 things thing_inside + = 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) <- things] + +tcExtendTyVarEnv :: [TyVar] -> TcM r -> TcM r +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, + tcl_rdr = rdr_env}) -> let - extend_list = [ (getName tv, (kindToTcKind (tyVarKind tv), Nothing, ATyVar tv)) - | tv <- tyvars - ] - te' = addListToUFM te extend_list - new_tv_set = mkVarSet tyvars - in_scope_tvs' = in_scope_tvs `unionVarSet` new_tv_set + le' = extendNameEnvList le binds + rdr_env' = extendLocalRdrEnv rdr_env (map fst binds) + 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 ... + -- f (_::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 (TcEnv te' ve (in_scope_tvs', gtvs')) scope - --- 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 s r -> TcM s r -tcExtendTyVarEnvForMeths sig_tyvars inst_tyvars thing_inside - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> + tc_extend_gtvs gtvs new_tv_set `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs', tcl_rdr = rdr_env'}) thing_inside +\end{code} + + +\begin{code} +tcExtendLocalValEnv :: [TcId] -> TcM a -> TcM a +tcExtendLocalValEnv ids thing_inside + = getLclEnv `thenM` \ env -> let - te' = addListToUFM te stuff + 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 + rdr_env' = extendLocalRdrEnv (tcl_rdr env) (map idName ids) in - tcSetEnv (TcEnv te' ve gtvs) thing_inside + tc_extend_gtvs (tcl_tyvars env) extra_global_tyvars `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs', tcl_rdr = rdr_env'}) 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] + 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 + rdr_env' = extendLocalRdrEnv (tcl_rdr env) (map fst names_w_ids) + in + tc_extend_gtvs (tcl_tyvars env) extra_global_tyvars `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs', tcl_rdr = rdr_env'}) 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 - stuff = [ (getName sig_tv, (kindToTcKind (tyVarKind inst_tv), Nothing, ATyVar inst_tv)) - | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars - ] + 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 tidy_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} -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 +%************************************************************************ +%* * +\subsection{The global tyvars} +%* * +%************************************************************************ + +\begin{code} tc_extend_gtvs gtvs extra_global_tvs - = tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - let - new_global_tyvars = global_tvs `unionVarSet` extra_global_tvs - in - tcNewMutVar new_global_tyvars + = 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. @@ -229,200 +404,214 @@ To improve subsequent calls to the same function it writes the zonked set back i the environment. \begin{code} -tcGetGlobalTyVars :: NF_TcM s TcTyVarSet +tcGetGlobalTyVars :: TcM TcTyVarSet tcGetGlobalTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve (_,gtvs)) -> - tcReadMutVar gtvs `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_` - 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) + = 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} -Type constructors and classes +%************************************************************************ +%* * +\subsection{Rules} +%* * +%************************************************************************ \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 +tcExtendRules :: [LRuleDecl 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 lcl_rules thing_inside + = do { env <- getGblEnv + ; let + env' = env { tcg_rules = lcl_rules ++ tcg_rules env } + ; setGblEnv env' thing_inside } \end{code} -Looking up in the environments. +%************************************************************************ +%* * + Arrow notation proc levels +%* * +%************************************************************************ \begin{code} -tcLookupTy :: Name -> NF_TcM s (TcKind, Maybe Arity, TcTyThing) -tcLookupTy name - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM te name of { - Just thing -> returnNF_Tc thing ; - Nothing -> - - case maybeWiredInTyConName name of - Just tc -> returnNF_Tc (kindToTcKind (tyConKind tc), maybe_arity, ATyCon tc) - where - maybe_arity | isSynTyCon tc = Just (tyConArity tc) - | otherwise = Nothing - - Nothing -> -- This can happen if an interface-file - -- unfolding is screwed up - failWithTc (tyNameOutOfScope name) - } - -tcLookupClass :: Name -> NF_TcM s Class -tcLookupClass name - = tcLookupTy name `thenNF_Tc` \ (_, _, AClass clas) -> - returnNF_Tc clas - -tcLookupTyCon :: Name -> NF_TcM s TyCon -tcLookupTyCon name - = tcLookupTy name `thenNF_Tc` \ (_, _, ATyCon tycon) -> - returnNF_Tc tycon - -tcLookupClassByKey :: Unique -> NF_TcM s Class -tcLookupClassByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM_Directly te key of - Just (_, _, AClass cl) -> returnNF_Tc cl - other -> pprPanic "tcLookupClassByKey:" (pprUnique10 key) - -tcLookupTyConByKey :: Unique -> NF_TcM s TyCon -tcLookupTyConByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - case lookupUFM_Directly te key of - Just (_, _, ATyCon tc) -> returnNF_Tc tc - other -> pprPanic "tcLookupTyConByKey:" (pprUnique10 key) +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} + +%************************************************************************ +%* * + Meta level +%* * +%************************************************************************ +\begin{code} +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 + 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{The value environment} +\subsection{Making new Ids} %* * %************************************************************************ -\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 +Constructing new Ids -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 +\begin{code} +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 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} -tcLookupValue :: Name -> NF_TcM s Id -- Panics if not found -tcLookupValue name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc id - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM ve def name) - where - def = pprPanic "tcLookupValue:" (ppr name) - -tcLookupValueMaybe :: Name -> NF_TcM s (Maybe Id) -tcLookupValueMaybe name - = case maybeWiredInIdName name of - Just id -> returnNF_Tc (Just id) - Nothing -> tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupUFM ve name) - -tcLookupValueByKey :: Unique -> NF_TcM s Id -- Panics if not found -tcLookupValueByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (explicitLookupValueByKey ve key) - -tcLookupValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id) -tcLookupValueByKeyMaybe key - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc (lookupUFM_Directly ve key) - -tcGetValueEnv :: NF_TcM s ValueEnv -tcGetValueEnv - = tcGetEnv `thenNF_Tc` \ (TcEnv te ve gtvs) -> - returnNF_Tc ve - -tcSetValueEnv :: ValueEnv -> TcM s a -> TcM s a -tcSetValueEnv ve scope - = tcGetEnv `thenNF_Tc` \ (TcEnv te _ gtvs) -> - tcSetEnv (TcEnv te ve gtvs) scope - --- Non-monadic version, environment given explicitly -explicitLookupValueByKey :: ValueEnv -> Unique -> Id -explicitLookupValueByKey ve key - = lookupWithDefaultUFM_Directly ve def key - where - def = pprPanic "lookupValueByKey:" (pprUnique10 key) - -explicitLookupValue :: ValueEnv -> Name -> Maybe Id -explicitLookupValue ve name - = case maybeWiredInIdName name of - Just id -> Just id - Nothing -> lookupUFM ve name - - -- Extract the IdInfo from an IfaceSig imported from an interface file -tcAddImportedIdInfo :: ValueEnv -> Id -> Id -tcAddImportedIdInfo unf_env id - | isLocallyDefined id -- Don't look up locally defined Ids, because they - -- have explicit local definitions, so we get a black hole! - = id - | otherwise - = id `setIdInfo` new_info - -- The Id must be returned without a data dependency on maybe_id +newDFunName :: Class -> [Type] -> SrcLoc -> TcM Name +newDFunName clas (ty:_) loc + = newUnique `thenM` \ uniq -> + returnM (mkInternalName uniq (mkDFunOcc dfun_string) loc) where - new_info = -- pprTrace "tcAdd" (ppr id) $ - case explicitLookupValue unf_env (getName id) of - Nothing -> vanillaIdInfo - Just imported_id -> idInfo imported_id - -- ToDo: could check that types are the same + -- Any string that is somewhat unique will do + dfun_string = occNameString (getOccName clas) ++ occNameString (getDFunTyKey ty) + +newDFunName clas [] loc = pprPanic "newDFunName" (ppr clas <+> ppr loc) \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 + +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} -newLocalId :: OccName -> TcType -> SrcLoc -> NF_TcM s TcId -newLocalId name ty loc - = tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkUserLocal name uniq ty loc) - -newSpecPragmaId :: Name -> TcType -> NF_TcM s TcId -newSpecPragmaId name ty - = tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (mkSpecPragmaId (nameOccName name) uniq ty (getSrcLoc name)) +data InstInfo + = InstInfo { + iDFunId :: DFunId, -- The dfun id + iBinds :: InstBindings + } + +data InstBindings + = VanillaInst -- The normal case + (LHsBinds Name) -- Bindings + [LSig Name] -- 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 info = pprInstInfo info $$ nest 2 (details (iBinds info)) + where + details (VanillaInst b _) = pprLHsBinds b + details (NewTypeDerived _) = text "Derived from the representation type" + +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} @@ -433,11 +622,17 @@ newSpecPragmaId name ty %************************************************************************ \begin{code} -badCon con_id - = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor") -badPrimOp op - = quotes (ppr op) <+> ptext SLIT("is not a primop") +notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+> + ptext SLIT("is not in scope")) -tyNameOutOfScope name - = quotes (ppr name) <+> ptext SLIT("is not in scope") +wrongThingErr expected thing name + = failWithTc (pp_thing thing <+> quotes (ppr name) <+> + ptext SLIT("used as a") <+> text expected) + where + pp_thing (AGlobal (ATyCon _)) = ptext SLIT("Type constructor") + pp_thing (AGlobal (AClass _)) = ptext SLIT("Class") + pp_thing (AGlobal (AnId _)) = ptext SLIT("Identifier") + pp_thing (AGlobal (ADataCon _)) = ptext SLIT("Data constructor") + pp_thing (ATyVar _) = ptext SLIT("Type variable") + pp_thing (ATcId _ _ _) = ptext SLIT("Local identifier") \end{code}