X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=31d81a4bd6d6712086978343309dc3e88449dc6e;hb=edf6bdfb5dee21f9bc5077083e5350ee64efffbc;hp=896d581eb66dcdaca3255d8714996c443ef828e8;hpb=26741ec416bae2c502ef00a2ba0e79050a32cb67;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 896d581..31d81a4 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,222 +1,388 @@ \begin{code} -#include "HsVersions.h" - module TcEnv( - TcEnv, - - initEnv, getEnv_LocalIds, getEnv_TyCons, getEnv_Classes, + TyThing(..), TcTyThing(..), TcId, + + -- Instance environment, and InstInfo type + InstInfo(..), iDFunId, pprInstInfo, pprInstInfoDetails, + simpleInstInfoClsTy, simpleInstInfoTy, simpleInstInfoTyCon, + InstBindings(..), + + -- Global environment + tcExtendGlobalEnv, + tcExtendGlobalValEnv, + tcLookupLocatedGlobal, tcLookupGlobal, + tcLookupGlobalId, tcLookupTyCon, tcLookupClass, tcLookupDataCon, + tcLookupLocatedGlobalId, tcLookupLocatedTyCon, + tcLookupLocatedClass, - tcTyVarScope, tcTyVarScopeGivenKinds, tcLookupTyVar, + -- Local environment + tcExtendKindEnv, tcExtendKindEnvTvs, + tcExtendTyVarEnv, tcExtendTyVarEnv2, + tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2, + tcLookup, tcLookupLocated, tcLookupLocalIds, + tcLookupId, tcLookupTyVar, + lclEnvElts, getInLocalScope, findGlobals, + wrongThingErr, pprBinders, + + tcExtendRecEnv, -- For knot-tying + + -- Rules + tcExtendRules, - tcExtendTyConEnv, tcLookupTyCon, tcLookupTyConByKey, - tcExtendClassEnv, tcLookupClass, tcLookupClassByKey, - tcGetTyConsAndClasses, + -- Global type variables + tcGetGlobalTyVars, - tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcLookupLocalValue, tcLookupLocalValueOK, tcLookupLocalValueByKey, - tcLookupGlobalValue, tcLookupGlobalValueByKey, + -- Template Haskell stuff + checkWellStaged, spliceOK, bracketOK, tcMetaTy, thLevel, + topIdLvl, - newMonoIds, newLocalIds, newLocalId, - tcGetGlobalTyVars, tcExtendGlobalTyVars + -- New Ids + newLocalName, newDFunName ) where +#include "HsVersions.h" -IMP_Ubiq() -IMPORT_DELOOPER(TcMLoop) -- for paranoia checking - -import Id ( SYN_IE(Id), GenId, idType, mkUserLocal ) -import TcHsSyn ( TcIdBndr(..), TcIdOcc(..) ) -import TcKind ( TcKind, newKindVars, tcDefaultKind, kindToTcKind ) -import TcType ( TcType(..), TcMaybe, TcTyVar(..), TcTyVarSet(..), - newTyVarTys, tcInstTyVars, zonkTcTyVars - ) -import TyVar ( mkTyVar, tyVarKind, unionTyVarSets, emptyTyVarSet ) -import Type ( tyVarsOfTypes ) -import TyCon ( TyCon, tyConKind, synTyConArity ) -import Class ( SYN_IE(Class), GenClass, classSig ) - -import TcMonad hiding ( rnMtoTcM ) - -import Name ( getOccName, getSrcLoc, Name{-instance NamedThing-} ) -import PprStyle -import Pretty -import RnHsSyn ( RnName(..) ) -import Type ( splitForAllTy ) -import Unique ( pprUnique10, pprUnique{-ToDo:rm-} ) -import UniqFM -import Util ( zipEqual, zipWithEqual, zipWith3Equal, zipLazy, - panic, pprPanic, pprTrace{-ToDo:rm-} +import HsSyn ( LRuleDecl, LHsBinds, LSig, + LHsTyVarBndr, HsTyVarBndr(..), pprLHsBinds ) +import TcIface ( tcImportDecl ) +import IfaceEnv ( newGlobalBinder ) +import TcRnMonad +import TcMType ( zonkTcType, zonkTcTyVarsAndFV ) +import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, TcType, + tyVarsOfType, tyVarsOfTypes, mkGenTyConApp, + getDFunTyKey, tcTyConAppTyCon, tcGetTyVar, mkTyVarTy, + tidyOpenType ) +import qualified Type ( getTyVar_maybe ) +import Id ( idName, isLocalId ) +import Var ( TyVar, Id, idType, tyVarName ) +import VarSet +import VarEnv +import RdrName ( extendLocalRdrEnv ) +import InstEnv ( Instance, DFunId, instanceDFunId, instanceHead ) +import DataCon ( DataCon ) +import TyCon ( TyCon ) +import Class ( Class ) +import Name ( Name, NamedThing(..), getSrcLoc, nameModule, isExternalName ) +import PrelNames ( thFAKE ) +import NameEnv +import OccName ( mkDFunOcc, occNameString ) +import HscTypes ( extendTypeEnvList, lookupType, + TyThing(..), tyThingId, tyThingDataCon, + ExternalPackageState(..) ) + +import SrcLoc ( SrcLoc, Located(..) ) +import Outputable \end{code} -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ -\begin{code} -data TcEnv s = TcEnv - (TyVarEnv s) - (TyConEnv s) - (ClassEnv s) - (ValueEnv Id) -- Globals - (ValueEnv (TcIdBndr s)) -- Locals - (MutableVar 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) -type ValueEnv id = UniqFM id - -initEnv :: MutableVar 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] -\end{code} +%************************************************************************ +%* * +%* 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. -Making new TcTyVars, with knot tying! -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -tcTyVarScopeGivenKinds - :: [Name] -- Names of some type variables - -> [TcKind s] - -> ([TyVar] -> TcM s a) -- Thing to type check in their scope - -> TcM s a -- Result - -tcTyVarScopeGivenKinds names kinds thing_inside - = fixTc (\ ~(rec_tyvars, _) -> - -- Ok to look at names, kinds, but not tyvars! - - tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - tve' = addListToUFM tve (zipEqual "tcTyVarScopeGivenKinds" names (kinds `zipLazy` rec_tyvars)) - in - tcSetEnv (TcEnv tve' tce ce gve lve gtvs) - (thing_inside rec_tyvars) `thenTc` \ result -> - - -- Get the tyvar's Kinds from their TcKinds - mapNF_Tc tcDefaultKind kinds `thenNF_Tc` \ kinds' -> - - -- Construct the real TyVars - let - tyvars = zipWithEqual "tcTyVarScopeGivenKinds" mkTyVar names kinds' - in - returnTc (tyvars, result) - ) `thenTc` \ (_,result) -> - returnTc result - -tcTyVarScope names thing_inside - = newKindVars (length names) `thenNF_Tc` \ kinds -> - tcTyVarScopeGivenKinds names kinds thing_inside -\end{code} +tcLookupLocatedGlobal :: Located Name -> TcM TyThing +-- c.f. IfaceEnvEnv.tcIfaceGlobal +tcLookupLocatedGlobal name + = addLocM tcLookupGlobal name + +tcLookupGlobal :: Name -> TcM TyThing +-- The Name is almost always an ExternalName, but not always +-- In GHCi, we may make command-line bindings (ghci> let x = True) +-- that bind a GlobalId, but with an InternalName +tcLookupGlobal name + = do { env <- getGblEnv + + -- Try local envt + ; case lookupNameEnv (tcg_type_env env) name of { + Just thing -> return thing ; + Nothing -> do + + -- Try global envt + { (eps,hpt) <- getEpsAndHpt + ; case lookupType hpt (eps_PTE eps) name of { + Just thing -> return thing ; + Nothing -> do + + -- Should it have been in the local envt? + { let mod = nameModule name + ; if mod == tcg_mod env || mod == thFAKE then + notFound name -- It should be local, so panic + -- The thFAKE possibility is because it + -- might be in a declaration bracket + else + tcImportDecl name -- Go find it in an interface + }}}}} + +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 DataCon +tcLookupDataCon con_name + = 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 -The Kind, TyVar, Class and TyCon envs -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +tcLookupLocatedClass :: Located Name -> TcM Class +tcLookupLocatedClass = addLocM tcLookupClass -Extending the environments. Notice the uses of @zipLazy@, which makes sure -that the knot-tied TyVars, TyCons and Classes aren't looked at too early. +tcLookupLocatedTyCon :: Located Name -> TcM TyCon +tcLookupLocatedTyCon = addLocM tcLookupTyCon +\end{code} -\begin{code} -tcExtendTyConEnv :: [(RnName,Maybe Arity)] -> [TyCon] -> TcM s r -> TcM s r +%************************************************************************ +%* * + Extending the global environment +%* * +%************************************************************************ -tcExtendTyConEnv names_w_arities tycons scope - = newKindVars (length names_w_arities) `thenNF_Tc` \ kinds -> - tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - tce' = addListToUFM tce [ (name, (kind, arity, tycon)) - | ((name,arity), (kind,tycon)) - <- zipEqual "tcExtendTyConEnv" names_w_arities (kinds `zipLazy` tycons) - ] - in - tcSetEnv (TcEnv tve tce' ce gve lve gtvs) scope `thenTc` \ result -> - mapNF_Tc tcDefaultKind kinds `thenNF_Tc_` - returnTc result +\begin{code} +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} -tcExtendClassEnv :: [RnName] -> [Class] -> TcM s r -> TcM s r -tcExtendClassEnv names classes scope - = newKindVars (length names) `thenNF_Tc` \ kinds -> - tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - ce' = addListToUFM ce (zipEqual "tcExtendClassEnv" names (kinds `zipLazy` classes)) - in - tcSetEnv (TcEnv tve tce ce' gve lve gtvs) scope `thenTc` \ result -> - mapNF_Tc tcDefaultKind kinds `thenNF_Tc_` - returnTc result +\begin{code} +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} -Looking up in the environments. +%************************************************************************ +%* * +\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 TcTyVar tcLookupTyVar name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM tve (pprPanic "tcLookupTyVar:" (ppr PprShowAll name)) name) - + = tcLookup name `thenM` \ thing -> + case thing of + ATyVar _ ty -> returnM (tcGetTyVar "tcLookupTyVar" ty) + 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} -tcLookupTyCon (WiredInTyCon tc) -- wired in tycons - = returnNF_Tc (kindToTcKind (tyConKind tc), synTyConArity tc, tc) +\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] -tcLookupTyCon name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM tce (pprPanic "tcLookupTyCon:" (ppr PprShowAll name)) name) - -tcLookupTyConByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - (kind, arity, tycon) = lookupWithDefaultUFM_Directly tce - (pprPanic "tcLookupTyCon:" (pprUnique10 uniq)) - uniq +tcExtendKindEnvTvs :: [LHsTyVarBndr Name] -> TcM r -> TcM r +tcExtendKindEnvTvs bndrs thing_inside + = updLclEnv upd thing_inside + where + upd lcl_env = lcl_env { tcl_env = extend (tcl_env lcl_env) } + extend env = extendNameEnvList env pairs + pairs = [(n, AThing k) | L _ (KindedTyVar n k) <- bndrs] + +tcExtendTyVarEnv :: [TyVar] -> TcM r -> TcM r +tcExtendTyVarEnv tvs thing_inside + = tcExtendTyVarEnv2 [(tyVarName tv, mkTyVarTy tv) | tv <- tvs] thing_inside + +tcExtendTyVarEnv2 :: [(Name,TcType)] -> TcM r -> TcM r +tcExtendTyVarEnv2 binds thing_inside + = getLclEnv `thenM` \ env@(TcLclEnv {tcl_env = le, + tcl_tyvars = gtvs, + tcl_rdr = rdr_env}) -> + let + rdr_env' = extendLocalRdrEnv rdr_env (map fst binds) + new_tv_set = tyVarsOfTypes (map snd binds) + le' = extendNameEnvList le [(name, ATyVar name ty) | (name, ty) <- binds] in - returnNF_Tc tycon + -- It's important to add the in-scope tyvars to the global tyvar set + -- as well. Consider + -- 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 `thenM` \ gtvs' -> + setLclEnv (env {tcl_env = le', tcl_tyvars = gtvs', tcl_rdr = rdr_env'}) thing_inside +\end{code} -tcLookupClass name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> --- pprTrace "tcLookupClass:" (ppCat [ppStr "Uniq:", pprUnique10 (uniqueOf name), ppStr "; avail:", ppCat (map (pprUnique10 . fst) (ufmToList ce))]) $ --- pprTrace "tcLookupClass:" (ppCat [ppStr "Uniq:", pprUnique (uniqueOf name), ppStr "; avail:", ppCat (map (pprUnique . fst) (ufmToList ce))]) $ - returnNF_Tc (lookupWithDefaultUFM ce (pprPanic "tcLookupClass:" (ppr PprShowAll name)) name) -tcLookupClassByKey uniq - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> +\begin{code} +tcExtendIdEnv :: [TcId] -> TcM a -> TcM a +-- Invariant: the TcIds are fully zonked. Reasons: +-- (a) The kinds of the forall'd type variables are defaulted +-- (see Kind.defaultKind, done in zonkQuantifiedTyVar) +-- (b) There are no via-Indirect occurrences of the bound variables +-- in the types, because instantiation does not look through such things +-- (c) The call to tyVarsOfTypes is ok without looking through refs +tcExtendIdEnv ids thing_inside = tcExtendIdEnv2 [(idName id, id) | id <- ids] thing_inside + +tcExtendIdEnv1 :: Name -> TcId -> TcM a -> TcM a +tcExtendIdEnv1 name id thing_inside = tcExtendIdEnv2 [(name,id)] thing_inside + +tcExtendIdEnv2 :: [(Name,TcId)] -> TcM a -> TcM a +-- Invariant: the TcIds are fully zonked (see tcExtendIdEnv above) +tcExtendIdEnv2 names_w_ids thing_inside + = getLclEnv `thenM` \ env -> let - (kind, clas) = lookupWithDefaultUFM_Directly ce - (pprPanic "tcLookupClassByKey:" (pprUnique10 uniq)) - uniq + extra_global_tyvars = tyVarsOfTypes [idType id | (name,id) <- names_w_ids] + th_lvl = thLevel (tcl_th_ctxt env) + extra_env = [(name, ATcId id th_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 - 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]) + 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} - -Extending and consulting the value environment -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -tcExtendGlobalValEnv ids scope - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - let - gve' = addListToUFM_Directly gve [(uniqueOf id, id) | id <- ids] +----------------------- +-- 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 - tcSetEnv (TcEnv tve tce ce gve' lve gtvs) scope - -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 + returnM (tidy_env', Just msg) + +find_thing ignore_it tidy_env (ATyVar tv ty) + = zonkTcType ty `thenM` \ tv_ty -> + if ignore_it tv_ty then + returnM (tidy_env, Nothing) + else let + -- The name tv is scoped, so we don't need to tidy it + (tidy_env1, tidy_ty) = tidyOpenType tidy_env tv_ty + msg = sep [ptext SLIT("Scoped type variable") <+> quotes (ppr tv) <+> eq_stuff, nest 2 bound_at] + + eq_stuff | Just tv' <- Type.getTyVar_maybe tv_ty, + getOccName tv == getOccName tv' = empty + | otherwise = equals <+> ppr tidy_ty + -- It's ok to use Type.getTyVar_maybe because ty is zonked by now + bound_at = parens $ ptext SLIT("bound at:") <+> ppr (getSrcLoc tv) in - tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' -> + returnM (tidy_env1, Just msg) +\end{code} + - tcSetEnv (TcEnv tve tce ce gve lve' gtvs') scope +%************************************************************************ +%* * +\subsection{The global tyvars} +%* * +%************************************************************************ + +\begin{code} +tc_extend_gtvs gtvs 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. @@ -224,107 +390,206 @@ 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 :: 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` extra_global_tvs - in - tcNewMutVar new_global_tyvars `thenNF_Tc` \ gtvs' -> - tcSetEnv (TcEnv tve tce ce gve lve gtvs') scope + = 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} -\begin{code} -tcLookupLocalValue :: RnName -> 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 -> RnName -> 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) +%************************************************************************ +%* * +\subsection{Rules} +%* * +%************************************************************************ +\begin{code} +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} -tcLookupGlobalValue :: RnName -> NF_TcM s Id -tcLookupGlobalValue (WiredInId id) -- wired in ids - = returnNF_Tc id +%************************************************************************ +%* * + Meta level +%* * +%************************************************************************ -tcLookupGlobalValue name - = tcGetEnv `thenNF_Tc` \ (TcEnv tve tce ce gve lve gtvs) -> - returnNF_Tc (lookupWithDefaultUFM gve def name) - where -#ifdef DEBUG - def = pprPanic "tcLookupGlobalValue:" (ppr PprDebug name) -#else - def = panic "tcLookupGlobalValue" -#endif - -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) +\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 -#ifdef DEBUG - def = pprPanic "tcLookupGlobalValueByKey:" (pprUnique10 uniq) -#else - def = panic "tcLookupGlobalValueByKey" -#endif - + 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} -Constructing new Ids -~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{The InstInfo type} +%* * +%************************************************************************ -\begin{code} -newMonoIds :: [RnName] -> Kind -> ([TcIdBndr s] -> TcM s a) -> TcM s a +The InstInfo type summarises the information in an instance declaration -newMonoIds names kind m - = newTyVarTys no_of_names kind `thenNF_Tc` \ tys -> - tcGetUniques no_of_names `thenNF_Tc` \ uniqs -> - let - new_ids = zipWith3Equal "newMonoIds" mk_id names uniqs tys + instance c => k (t tvs) where b - mk_id name uniq ty - = let - name_str = case (getOccName name) of { Unqual n -> n; Qual m n -> n } - in - mkUserLocal name_str uniq ty (getSrcLoc name) - in - tcExtendLocalValEnv names new_ids (m new_ids) +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 { + iSpec :: Instance, -- Includes the dfun id. Its forall'd type + iBinds :: InstBindings -- variables scope over the stuff in InstBindings! + } + +iDFunId :: InstInfo -> DFunId +iDFunId info = instanceDFunId (iSpec info) + +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 - no_of_names = length names - -newLocalId :: FAST_STRING -> TcType s -> NF_TcM s (TcIdOcc s) -newLocalId name ty - = tcGetSrcLoc `thenNF_Tc` \ loc -> - tcGetUnique `thenNF_Tc` \ uniq -> - returnNF_Tc (TcId (mkUserLocal name uniq ty loc)) - -newLocalIds :: [FAST_STRING] -> [TcType s] -> NF_TcM s [TcIdOcc 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 = TcId (mkUserLocal name uniq ty loc) - in - returnNF_Tc new_ids + details (VanillaInst b _) = pprLHsBinds b + details (NewTypeDerived _) = text "Derived from the representation type" + +simpleInstInfoClsTy :: InstInfo -> (Class, Type) +simpleInstInfoClsTy info = case instanceHead (iSpec info) of + (_, _, cls, [ty]) -> (cls, ty) + +simpleInstInfoTy :: InstInfo -> Type +simpleInstInfoTy info = snd (simpleInstInfoClsTy info) + +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} + +Make a name for the dict fun for an instance decl. It's an *external* +name, like otber top-level names, and hence must be made with newGlobalBinder. + +\begin{code} +newDFunName :: Class -> [Type] -> SrcLoc -> TcM Name +newDFunName clas (ty:_) loc + = do { index <- nextDFunIndex + ; is_boot <- tcIsHsBoot + ; mod <- getModule + ; let info_string = occNameString (getOccName clas) ++ + occNameString (getDFunTyKey ty) + dfun_occ = mkDFunOcc info_string is_boot index + + ; newGlobalBinder mod dfun_occ Nothing loc } + +newDFunName clas [] loc = pprPanic "newDFunName" (ppr clas <+> ppr loc) \end{code} +%************************************************************************ +%* * +\subsection{Errors} +%* * +%************************************************************************ + +\begin{code} +pprBinders :: [Name] -> SDoc +-- Used in error messages +-- Use quotes for a single one; they look a bit "busy" for several +pprBinders [bndr] = quotes (ppr bndr) +pprBinders bndrs = pprWithCommas ppr bndrs + +notFound name + = failWithTc (ptext SLIT("GHC internal error:") <+> quotes (ppr name) <+> + ptext SLIT("is not in scope")) + +wrongThingErr expected thing name + = failWithTc (pprTcTyThingCategory thing <+> quotes (ppr name) <+> + ptext SLIT("used as a") <+> text expected) +\end{code}