X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcEnv.lhs;h=98db64c9760e61fb78ae2c9905e0a36be458a356;hp=1f9d3050eff2fd7094b829ee8ace3e4949b43511;hb=9319fbaf14f420cbbd9e670093cc86c5f04b7800;hpb=1c9ffbe64003cef8a686ff1e29aae160e314775e diff --git a/compiler/typecheck/TcEnv.lhs b/compiler/typecheck/TcEnv.lhs index 1f9d305..98db64c 100644 --- a/compiler/typecheck/TcEnv.lhs +++ b/compiler/typecheck/TcEnv.lhs @@ -3,13 +3,6 @@ % \begin{code} -{-# OPTIONS -w #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings --- for details - module TcEnv( TyThing(..), TcTyThing(..), TcId, @@ -71,7 +64,6 @@ import FamInstEnv import DataCon import TyCon import TypeRep -import Coercion import Class import Name import PrelNames @@ -156,21 +148,21 @@ tcLookupDataCon name = do thing <- tcLookupGlobal name case thing of ADataCon con -> return con - other -> wrongThingErr "data constructor" (AGlobal thing) name + _ -> wrongThingErr "data constructor" (AGlobal thing) name tcLookupClass :: Name -> TcM Class tcLookupClass name = do thing <- tcLookupGlobal name case thing of AClass cls -> return cls - other -> wrongThingErr "class" (AGlobal thing) name - + _ -> wrongThingErr "class" (AGlobal thing) name + tcLookupTyCon :: Name -> TcM TyCon tcLookupTyCon name = do thing <- tcLookupGlobal name case thing of ATyCon tc -> return tc - other -> wrongThingErr "type constructor" (AGlobal thing) name + _ -> wrongThingErr "type constructor" (AGlobal thing) name tcLookupLocatedGlobalId :: Located Name -> TcM Id tcLookupLocatedGlobalId = addLocM tcLookupId @@ -208,7 +200,7 @@ tcLookupFamInst tycon tys ; case lookupFamInstEnv instEnv tycon tys of [(fam_inst, rep_tys)] -> return $ Just (famInstTyCon fam_inst, rep_tys) - other -> return Nothing + _ -> return Nothing } \end{code} @@ -267,7 +259,7 @@ tcLookupTyVar name = do thing <- tcLookup name case thing of ATyVar _ ty -> return (tcGetTyVar "tcLookupTyVar" ty) - other -> pprPanic "tcLookupTyVar" (ppr name) + _ -> pprPanic "tcLookupTyVar" (ppr name) tcLookupId :: Name -> TcM Id -- Used when we aren't interested in the binding level, nor refinement. @@ -279,7 +271,7 @@ tcLookupId name = do case thing of ATcId { tct_id = id} -> return id AGlobal (AnId id) -> return id - other -> pprPanic "tcLookupId" (ppr name) + _ -> pprPanic "tcLookupId" (ppr name) tcLookupLocalIds :: [Name] -> TcM [TcId] -- We expect the variables to all be bound, and all at @@ -292,7 +284,7 @@ tcLookupLocalIds ns = do = case lookupNameEnv lenv name of Just (ATcId { tct_id = id, tct_level = lvl1 }) -> ASSERT( lvl == lvl1 ) id - other -> pprPanic "tcLookupLocalIds" (ppr name) + _ -> pprPanic "tcLookupLocalIds" (ppr name) lclEnvElts :: TcLclEnv -> [TcTyThing] lclEnvElts env = nameEnvElts (tcl_env env) @@ -431,6 +423,8 @@ findGlobals tvs tidy_env = do ignore_it ty = tvs `disjointVarSet` tyVarsOfType ty ----------------------- +find_thing :: (TcType -> Bool) -> TidyEnv -> TcTyThing + -> TcM (TidyEnv, Maybe SDoc) find_thing ignore_it tidy_env (ATcId { tct_id = id }) = do id_ty <- zonkTcType (idType id) if ignore_it id_ty then @@ -438,7 +432,7 @@ find_thing ignore_it tidy_env (ATcId { tct_id = id }) = do 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") <+> + nest 2 (parens (ptext (sLit "bound at") <+> ppr (getSrcLoc id)))] in return (tidy_env', Just msg) @@ -450,13 +444,13 @@ find_thing ignore_it tidy_env (ATyVar tv ty) = do 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] + 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) + bound_at = parens $ ptext (sLit "bound at:") <+> ppr (getSrcLoc tv) in return (tidy_env1, Just msg) @@ -470,6 +464,7 @@ find_thing _ _ thing = pprPanic "find_thing" (ppr thing) %************************************************************************ \begin{code} +tc_extend_gtvs :: IORef VarSet -> VarSet -> TcM (IORef VarSet) tc_extend_gtvs gtvs extra_global_tvs = do global_tvs <- readMutVar gtvs newMutVar (global_tvs `unionVarSet` extra_global_tvs) @@ -539,14 +534,14 @@ checkWellStaged pp_thing bind_lvl use_stage | 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"))] + 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 $ -- E.g. \x -> $(f x) - 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] + 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 @@ -605,40 +600,43 @@ But local instance decls includes as well as explicit user written ones. \begin{code} -data InstInfo +data InstInfo a = InstInfo { iSpec :: Instance, -- Includes the dfun id. Its forall'd type - iBinds :: InstBindings -- variables scope over the stuff in InstBindings! + iBinds :: InstBindings a -- variables scope over the stuff in InstBindings! } -iDFunId :: InstInfo -> DFunId +iDFunId :: InstInfo a -> DFunId iDFunId info = instanceDFunId (iSpec info) -data InstBindings +data InstBindings a = VanillaInst -- The normal case - (LHsBinds Name) -- Bindings for the instance methods - [LSig Name] -- User pragmas recorded for generating + (LHsBinds a) -- Bindings for the instance methods + [LSig a] -- User pragmas recorded for generating -- specialised instances | NewTypeDerived -- Used for deriving instances of newtypes, where the -- witness dictionary is identical to the argument -- dictionary. Hence no bindings, no pragmas. -pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info))] +pprInstInfo :: InstInfo a -> SDoc +pprInstInfo info = vcat [ptext (sLit "InstInfo:") <+> ppr (idType (iDFunId info))] +pprInstInfoDetails :: OutputableBndr a => InstInfo a -> SDoc pprInstInfoDetails info = pprInstInfo info $$ nest 2 (details (iBinds info)) where details (VanillaInst b _) = pprLHsBinds b details NewTypeDerived = text "Derived from the representation type" -simpleInstInfoClsTy :: InstInfo -> (Class, Type) +simpleInstInfoClsTy :: InstInfo a -> (Class, Type) simpleInstInfoClsTy info = case instanceHead (iSpec info) of - (_, _, cls, [ty]) -> (cls, ty) + (_, _, cls, [ty]) -> (cls, ty) + _ -> panic "simpleInstInfoClsTy" -simpleInstInfoTy :: InstInfo -> Type +simpleInstInfoTy :: InstInfo a -> Type simpleInstInfoTy info = snd (simpleInstInfoClsTy info) -simpleInstInfoTyCon :: InstInfo -> TyCon +simpleInstInfoTyCon :: InstInfo a -> 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) @@ -689,13 +687,15 @@ pprBinders :: [Name] -> SDoc pprBinders [bndr] = quotes (ppr bndr) pprBinders bndrs = pprWithCommas ppr bndrs +notFound :: Name -> TcGblEnv -> TcM TyThing notFound name env - = failWithTc (vcat[ptext SLIT("GHC internal error:") <+> quotes (ppr name) <+> - ptext SLIT("is not in scope during type checking, but it passed the renamer"), - ptext SLIT("tcg_type_env of environment:") <+> ppr (tcg_type_env env)] + = failWithTc (vcat[ptext (sLit "GHC internal error:") <+> quotes (ppr name) <+> + ptext (sLit "is not in scope during type checking, but it passed the renamer"), + ptext (sLit "tcg_type_env of environment:") <+> ppr (tcg_type_env env)] ) +wrongThingErr :: String -> TcTyThing -> Name -> TcM a wrongThingErr expected thing name = failWithTc (pprTcTyThingCategory thing <+> quotes (ppr name) <+> - ptext SLIT("used as a") <+> text expected) + ptext (sLit "used as a") <+> text expected) \end{code}