X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=5ebfe58da7bb4fcd625ebad131df5d3de3ef6a58;hb=c7fd6356eb1ccab4b92fa548d52023cc221fa7c0;hp=cf86e56718eebfe79ffc5b1ca3fa0d34bc8d9198;hpb=f714e6b642fd614a9971717045ae47c3d871275e;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index cf86e56..5ebfe58 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -13,14 +13,12 @@ module TcEnv( tcLookupLocatedGlobal, tcLookupGlobal, tcLookupGlobalId, tcLookupTyCon, tcLookupClass, tcLookupDataCon, tcLookupLocatedGlobalId, tcLookupLocatedTyCon, - tcLookupLocatedClass, tcLookupLocatedDataCon, + tcLookupLocatedClass, - getInGlobalScope, - -- Local environment tcExtendKindEnv, - tcExtendTyVarEnv, tcExtendTyVarEnv2, - tcExtendLocalValEnv, tcExtendLocalValEnv2, + tcExtendTyVarEnv, tcExtendTyVarEnv2, + tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2, tcLookup, tcLookupLocated, tcLookupLocalIds, tcLookupId, tcLookupTyVar, lclEnvElts, getInLocalScope, findGlobals, @@ -47,18 +45,18 @@ module TcEnv( #include "HsVersions.h" -import HsSyn ( LRuleDecl, LHsBinds, LSig ) +import HsSyn ( LRuleDecl, LHsBinds, LSig, pprLHsBinds ) import TcIface ( tcImportDecl ) import TcRnMonad -import TcMType ( zonkTcType, zonkTcTyVar, zonkTcTyVarsAndFV ) -import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, +import TcMType ( zonkTcType, zonkTcTyVarsAndFV ) +import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, TcType, tyVarsOfType, tyVarsOfTypes, tcSplitDFunTy, mkGenTyConApp, - getDFunTyKey, tcTyConAppTyCon, tyVarBindingInfo, - tidyOpenType, tidyOpenTyVar + getDFunTyKey, tcTyConAppTyCon, tcGetTyVar, mkTyVarTy, + tidyOpenType, pprTyThingCategory ) import qualified Type ( getTyVar_maybe ) import Id ( idName, isLocalId ) -import Var ( TyVar, Id, idType ) +import Var ( TyVar, Id, idType, tyVarName ) import VarSet import VarEnv import RdrName ( extendLocalRdrEnv ) @@ -74,7 +72,6 @@ import HscTypes ( DFunId, extendTypeEnvList, lookupType, import SrcLoc ( SrcLoc, Located(..) ) import Outputable -import Maybe ( isJust ) \end{code} @@ -102,15 +99,13 @@ tcLookupGlobal name then -- It's defined in this module case lookupNameEnv (tcg_type_env env) name of Just thing -> return thing - Nothing -> notFound "tcLookupGlobal" name + Nothing -> notFound name -- Panic! else do -- It's imported - { eps <- getEps - ; hpt <- getHpt + { (eps,hpt) <- getEpsAndHpt ; case lookupType hpt (eps_PTE eps) name of Just thing -> return thing - Nothing -> do { traceIf (text "tcLookupGlobal" <+> ppr name) - ; initIfaceTcRn (tcImportDecl name) } + Nothing -> tcImportDecl name }} \end{code} @@ -143,9 +138,6 @@ tcLookupTyCon name tcLookupLocatedGlobalId :: Located Name -> TcM Id tcLookupLocatedGlobalId = addLocM tcLookupId -tcLookupLocatedDataCon :: Located Name -> TcM DataCon -tcLookupLocatedDataCon = addLocM tcLookupDataCon - tcLookupLocatedClass :: Located Name -> TcM Class tcLookupLocatedClass = addLocM tcLookupClass @@ -175,22 +167,6 @@ tcExtendGlobalValEnv ids thing_inside = tcExtendGlobalEnv [AnId id | id <- ids] thing_inside \end{code} -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} - - \begin{code} tcExtendRecEnv :: [(Name,TyThing)] -> TcM r -> TcM r -- Extend the global environments for the type/class knot tying game @@ -220,12 +196,12 @@ tcLookup name Nothing -> tcLookupGlobal name `thenM` \ thing -> returnM (AGlobal thing) -tcLookupTyVar :: Name -> TcM Id +tcLookupTyVar :: Name -> TcM TcTyVar tcLookupTyVar name = tcLookup name `thenM` \ thing -> case thing of - ATyVar tv -> returnM tv - other -> pprPanic "tcLookupTyVar" (ppr name) + 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 @@ -271,22 +247,17 @@ tcExtendKindEnv things thing_inside tcExtendTyVarEnv :: [TyVar] -> TcM r -> TcM r tcExtendTyVarEnv tvs thing_inside - = tc_extend_tv_env [(getName tv, ATyVar tv) | tv <- tvs] tvs thing_inside + = tcExtendTyVarEnv2 [(tyVarName tv, mkTyVarTy tv) | tv <- 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 +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 - le' = extendNameEnvList le binds rdr_env' = extendLocalRdrEnv rdr_env (map fst binds) - new_tv_set = mkVarSet tyvars + new_tv_set = tyVarsOfTypes (map snd binds) + le' = extendNameEnvList le [(name, ATyVar name ty) | (name, ty) <- binds] in -- It's important to add the in-scope tyvars to the global tyvar set -- as well. Consider @@ -300,22 +271,21 @@ tc_extend_tv_env binds tyvars thing_inside \begin{code} -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 - rdr_env' = extendLocalRdrEnv (tcl_rdr env) (map idName 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 - -tcExtendLocalValEnv2 :: [(Name,TcId)] -> TcM a -> TcM a -tcExtendLocalValEnv2 names_w_ids thing_inside +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 extra_global_tyvars = tyVarsOfTypes [idType id | (name,id) <- names_w_ids] @@ -367,23 +337,22 @@ find_thing ignore_it tidy_env (ATcId id _ _) in returnM (tidy_env', Just msg) -find_thing ignore_it tidy_env (ATyVar tv) - = zonkTcTyVar tv `thenM` \ tv_ty -> +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 - (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] + -- The name tv is scoped, so we don't need to tidy it + (tidy_env1, tidy_ty) = tidyOpenType tidy_env tv_ty + msg = sep [ppr tv <+> eq_stuff, nest 2 bound_at] eq_stuff | Just tv' <- Type.getTyVar_maybe tv_ty, - tv == tv' = empty + tv == tyVarName 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 + bound_at = ptext SLIT("bound at:") <+> ppr (getSrcLoc tv) in - returnM (tidy_env2, Just msg) + returnM (tidy_env1, Just msg) \end{code} @@ -510,7 +479,7 @@ topIdLvl id | isLocalId id = topLevel -- Indicates the legal transitions on bracket( [| |] ). bracketOK :: ThStage -> Maybe ThLevel bracketOK (Brack _ _ _) = Nothing -- Bracket illegal inside a bracket -bracketOK stage = (Just (thLevel stage + 1)) +bracketOK stage = Just (thLevel stage + 1) -- Indicates the legal transitions on splice($). spliceOK :: ThStage -> Maybe ThLevel @@ -581,8 +550,8 @@ as well as explicit user written ones. \begin{code} data InstInfo = InstInfo { - iDFunId :: DFunId, -- The dfun id - iBinds :: InstBindings + iDFunId :: DFunId, -- The dfun id. Its forall'd type variables + iBinds :: InstBindings -- scope over the stuff in InstBindings! } data InstBindings @@ -601,7 +570,7 @@ pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info)) pprInstInfoDetails info = pprInstInfo info $$ nest 2 (details (iBinds info)) where - details (VanillaInst b _) = ppr b + details (VanillaInst b _) = pprLHsBinds b details (NewTypeDerived _) = text "Derived from the representation type" simpleInstInfoTy :: InstInfo -> Type @@ -622,17 +591,15 @@ simpleInstInfoTyCon inst = tcTyConAppTyCon (simpleInstInfoTy inst) %************************************************************************ \begin{code} -notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+> - ptext SLIT("is not in scope")) +notFound name + = failWithTc (ptext SLIT("GHC internal error:") <+> 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") + pp_thing (AGlobal thing) = pprTyThingCategory thing + pp_thing (ATyVar _ _) = ptext SLIT("Type variable") + pp_thing (ATcId _ _ _) = ptext SLIT("Local identifier") \end{code}