X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcEnv.lhs;h=75e4a72074942cb3af1d6772239c2aff164e3e02;hb=0adb717549e8f6974453eb386350874be601bb03;hp=30999e89c20696274266f7c07adf17e83254621f;hpb=ff755dd9a0a0ad2f106c323852553ea247f16141;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcEnv.lhs b/ghc/compiler/typecheck/TcEnv.lhs index 30999e8..75e4a72 100644 --- a/ghc/compiler/typecheck/TcEnv.lhs +++ b/ghc/compiler/typecheck/TcEnv.lhs @@ -1,739 +1,609 @@ \begin{code} module TcEnv( - TcId, TcIdSet, tcInstId, - tcLookupDataCon, - - TcEnv, ValueEnv, TcTyThing(..), - - initEnv, getEnvTyCons, getEnvClasses, getEnvAllTyCons, - - tcExtendUVarEnv, tcLookupUVar, - - tcExtendTyVarEnv, tcExtendTyVarEnvForMeths, tcExtendTypeEnv, tcGetInScopeTyVars, - - tcLookupTy, - tcLookupTyConByKey, - tcLookupClassByKey, tcLookupClassByKey_maybe, - - tcExtendGlobalValEnv, tcExtendLocalValEnv, - tcGetValueEnv, tcSetValueEnv, - tcAddImportedIdInfo, - - tcLookupValue, tcLookupValueMaybe, - tcLookupValueByKey, tcLookupValueByKeyMaybe, - explicitLookupValueByKey, explicitLookupValue, - valueEnvIds, - - newLocalId, newSpecPragmaId, - tcGetGlobalTyVars, tcExtendGlobalTyVars, - - InstEnv, emptyInstEnv, addToInstEnv, - lookupInstEnv, InstLookupResult(..), - tcGetInstEnv, tcSetInstEnv, classInstEnv, - - badCon, badPrimOp + TyThing(..), TyThingDetails(..), TcTyThing(..), TcId, + + -- Instance environment, and InstInfo type + tcGetInstEnv, tcSetInstEnv, + InstInfo(..), pprInstInfo, pprInstInfoDetails, + simpleInstInfoTy, simpleInstInfoTyCon, + InstBindings(..), + + -- Global environment + tcExtendGlobalEnv, + tcExtendGlobalValEnv, + tcExtendGlobalTypeEnv, + tcLookupTyCon, tcLookupClass, tcLookupDataCon, + tcLookupGlobal_maybe, tcLookupGlobal, tcLookupGlobalId, + getInGlobalScope, + + -- Local environment + tcExtendKindEnv, + tcExtendTyVarEnv, tcExtendTyVarEnv2, + tcExtendLocalValEnv, tcExtendLocalValEnv2, + tcLookup, tcLookupLocalIds, tcLookup_maybe, + tcLookupId, tcLookupIdLvl, + getLclEnvElts, getInLocalScope, + + -- Instance environment + tcExtendLocalInstEnv, tcExtendInstEnv, + + -- Rules + tcExtendRules, + + -- Global type variables + tcGetGlobalTyVars, + + -- Random useful things + RecTcGblEnv, tcLookupRecId_maybe, + + -- Template Haskell stuff + wellStaged, spliceOK, bracketOK, tcMetaTy, metaLevel, + + -- New Ids + newLocalName, newDFunName, + + -- Misc + isLocalThing ) where #include "HsVersions.h" -import Id ( mkUserLocal, isDataConWrapId_maybe ) -import MkId ( mkSpecPragmaId ) -import Var ( TyVar, Id, setVarName, - idType, lazySetIdInfo, idInfo, tyVarKind, UVar, - ) -import TcType ( TcType, TcTyVar, TcTyVarSet, TcThetaType, - tcInstTyVars, zonkTcTyVars, - TcKind, kindToTcKind - ) +import RnHsSyn ( RenamedMonoBinds, RenamedSig ) +import HsSyn ( RuleDecl(..), ifaceRuleDeclName ) +import TcRnMonad +import TcMType ( zonkTcTyVarsAndFV ) +import TcType ( Type, ThetaType, TcKind, TcTyVar, TcTyVarSet, + tyVarsOfTypes, tcSplitDFunTy, mkGenTyConApp, + getDFunTyKey, tcTyConAppTyCon, + ) +import Rules ( extendRuleBase ) +import Id ( idName, isDataConWrapId_maybe ) +import Var ( TyVar, Id, idType ) import VarSet -import Type ( Kind, Type, 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(..), - NameEnv, emptyNameEnv, addToNameEnv, - extendNameEnv, lookupNameEnv, nameEnvElts +import CoreSyn ( IdCoreRule ) +import DataCon ( DataCon ) +import TyCon ( TyCon, DataConDetails ) +import Class ( Class, ClassOpItem ) +import Name ( Name, NamedThing(..), + getSrcLoc, mkInternalName, nameIsLocalOrFrom ) -import Unify ( unifyTyListsX, matchTys ) -import Unique ( pprUnique10, Unique, Uniquable(..) ) -import UniqFM -import Unique ( Uniquable(..) ) -import Util ( zipEqual, zipWith3Equal, mapAccumL ) +import NameEnv +import OccName ( mkDFunOcc, occNameString ) +import HscTypes ( DFunId, TypeEnv, extendTypeEnvList, + TyThing(..), ExternalPackageState(..) ) +import Rules ( RuleBase ) +import BasicTypes ( EP ) +import Module ( Module ) +import InstEnv ( InstEnv, extendInstEnv ) +import Maybes ( seqMaybe ) import SrcLoc ( SrcLoc ) -import FastString ( FastString ) -import Maybes import Outputable +import Maybe ( isJust ) +import List ( partition ) \end{code} + %************************************************************************ %* * -\subsection{TcId} + Meta level %* * %************************************************************************ - \begin{code} -type TcId = Id -- Type may be a TcType -type TcIdSet = IdSet - -tcLookupDataCon :: Name -> TcM s (DataCon, [TcType], TcType) -tcLookupDataCon con_name - = tcLookupValue con_name `thenNF_Tc` \ con_id -> - case isDataConWrapId_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') +instance Outputable Stage where + ppr Comp = text "Comp" + ppr (Brack l _ _) = text "Brack" <+> int l + ppr (Splice l) = text "Splice" <+> int l + + +metaLevel :: Stage -> Level +metaLevel Comp = topLevel +metaLevel (Splice l) = l +metaLevel (Brack l _ _) = l + +wellStaged :: Level -- Binding level + -> Level -- Use level + -> Bool +wellStaged bind_stage use_stage + = bind_stage <= use_stage + +-- Indicates the legal transitions on bracket( [| |] ). +bracketOK :: Stage -> Maybe Level +bracketOK (Brack _ _ _) = Nothing -- Bracket illegal inside a bracket +bracketOK stage = (Just (metaLevel stage + 1)) + +-- Indicates the legal transitions on splice($). +spliceOK :: Stage -> Maybe Level +spliceOK (Splice _) = Nothing -- Splice illegal inside splice +spliceOK stage = Just (metaLevel 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} -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. - %************************************************************************ %* * -\subsection{TcEnv} +\subsection{TyThingDetails} %* * %************************************************************************ -Data type declarations -~~~~~~~~~~~~~~~~~~~~~ +This data type is used to help tie the knot + when type checking type and class declarations \begin{code} -data TcEnv = TcEnv - UsageEnv - TypeEnv - ValueEnv - InstEnv - (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 UsageEnv = NameEnv UVar -type TypeEnv = NameEnv (TcKind, TcTyThing) -type ValueEnv = NameEnv Id - -valueEnvIds :: ValueEnv -> [Id] -valueEnvIds ve = nameEnvElts ve - -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 - | ADataTyCon TyCon - | ASynTyCon TyCon Arity - | AClass Class Arity - - -initEnv :: TcRef TcTyVarSet -> TcEnv -initEnv mut = TcEnv emptyNameEnv emptyNameEnv emptyNameEnv emptyInstEnv (emptyVarSet, mut) - -getEnvClasses (TcEnv _ te _ _ _) = [cl | (_, AClass cl _) <- nameEnvElts te] - -getEnvTyCons (TcEnv _ te _ _ _) = catMaybes (map get_tc (nameEnvElts te)) - where - get_tc (_, ADataTyCon tc) = Just tc - get_tc (_, ASynTyCon tc _) = Just tc - get_tc other = Nothing - -getEnvAllTyCons te_list = catMaybes (map get_tc te_list) - -- The 'all' means 'including the tycons from class decls' - where - get_tc (_, ADataTyCon tc) = Just tc - get_tc (_, ASynTyCon tc _) = Just tc - get_tc (_, AClass cl _) = Just (classTyCon cl) - get_tc other = Nothing +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{The usage environment} +\subsection{Basic lookups} %* * %************************************************************************ -Extending the usage environment - \begin{code} -tcExtendUVarEnv :: Name -> UVar -> TcM s r -> TcM s r -tcExtendUVarEnv uv_name uv scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - tcSetEnv (TcEnv (addToNameEnv ue uv_name uv) te ve ie gtvs) scope +type RecTcGblEnv = TcGblEnv +-- 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 + +tcLookupRecId_maybe :: RecTcGblEnv -> Name -> Maybe Id +tcLookupRecId_maybe env name = case lookup_global env name of + Just (AnId id) -> Just id + other -> Nothing \end{code} -Looking up in the environments. - -\begin{code} -tcLookupUVar :: Name -> NF_TcM s UVar -tcLookupUVar uv_name - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve _ gtvs) -> - case lookupNameEnv ue uv_name of - Just uv -> returnNF_Tc uv - Nothing -> failWithTc (uvNameOutOfScope uv_name) -\end{code} - - %************************************************************************ %* * -\subsection{The type environment} +\subsection{Making new Ids} %* * %************************************************************************ -\begin{code} -tcExtendTyVarEnv :: [TyVar] -> TcM s r -> TcM s r -tcExtendTyVarEnv tyvars scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (in_scope_tvs, gtvs)) -> - let - extend_list = [ (getName tv, (kindToTcKind (tyVarKind tv), ATyVar tv)) - | tv <- tyvars - ] - te' = extendNameEnv te extend_list - new_tv_set = mkVarSet tyvars - in_scope_tvs' = in_scope_tvs `unionVarSet` new_tv_set - 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 ... - -- 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 ue te' ve ie (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 ue te ve ie gtvs) -> - let - te' = extendNameEnv te stuff - in - tcSetEnv (TcEnv ue te' ve ie gtvs) thing_inside - where - stuff = [ (getName sig_tv, (kindToTcKind (tyVarKind inst_tv), ATyVar inst_tv)) - | (sig_tv, inst_tv) <- zipEqual "tcMeth" sig_tyvars inst_tyvars - ] - -tcExtendGlobalTyVars extra_global_tvs scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (in_scope,gtvs)) -> - tc_extend_gtvs gtvs extra_global_tvs `thenNF_Tc` \ gtvs' -> - tcSetEnv (TcEnv ue te ve ie (in_scope,gtvs')) scope +Constructing new Ids -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 +\begin{code} +newLocalName :: Name -> TcM Name +newLocalName name -- Make a clone + = newUnique `thenM` \ uniq -> + returnM (mkInternalName uniq (getOccName name) (getSrcLoc name)) \end{code} -@tcGetGlobalTyVars@ returns a fully-zonked set of tyvars free in the environment. -To improve subsequent calls to the same function it writes the zonked set back into -the environment. +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. \begin{code} -tcGetGlobalTyVars :: NF_TcM s TcTyVarSet -tcGetGlobalTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (_,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' +newDFunName :: Class -> [Type] -> SrcLoc -> TcM Name +newDFunName clas (ty:_) 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) -tcGetInScopeTyVars :: NF_TcM s [TcTyVar] -tcGetInScopeTyVars - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (in_scope_tvs, gtvs)) -> - returnNF_Tc (varSetElems in_scope_tvs) +newDFunName clas [] loc = pprPanic "newDFunName" (ppr clas <+> ppr loc) \end{code} +\begin{code} +isLocalThing :: NamedThing a => Module -> a -> Bool +isLocalThing mod thing = nameIsLocalOrFrom mod (getName thing) +\end{code} -Type constructors and classes +%************************************************************************ +%* * +\subsection{The global environment} +%* * +%************************************************************************ \begin{code} -tcExtendTypeEnv :: [(Name, (TcKind, 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 ue te ve ie gtvs) -> - let - te' = extendNameEnv te bindings - in - tcSetEnv (TcEnv ue te' ve ie gtvs) scope +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 + = 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 } + ist' = mkImpTypeEnv eps' hpt + ; setEps eps' + ; setGblEnv (env {tcg_type_env = ge', tcg_ist = ist'}) 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 + = do { env <- getGblEnv + ; let ge' = tcg_type_env env `plusNameEnv` extra_env + ; setGblEnv (env {tcg_type_env = ge'}) thing_inside } \end{code} -Looking up in the environments. +\begin{code} +lookup_global :: TcGblEnv -> Name -> Maybe TyThing + -- Try the global envt and then the global symbol table +lookup_global env name + = lookupNameEnv (tcg_type_env env) name + `seqMaybe` + tcg_ist env name + +tcLookupGlobal_maybe :: Name -> TcRn m (Maybe TyThing) +tcLookupGlobal_maybe name + = getGblEnv `thenM` \ env -> + returnM (lookup_global env name) +\end{code} + +A variety of global lookups, when we know what we are looking for. \begin{code} -tcLookupTy :: Name -> NF_TcM s (TcKind, TcTyThing) -tcLookupTy name - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - case lookupNameEnv te name of { - Just thing -> returnNF_Tc thing ; - Nothing -> - - case maybeWiredInTyConName name of - Just tc | isSynTyCon tc -> returnNF_Tc (kindToTcKind (tyConKind tc), ASynTyCon tc (tyConArity tc)) - | otherwise -> returnNF_Tc (kindToTcKind (tyConKind tc), ADataTyCon tc) - - Nothing -> -- This can happen if an interface-file - -- unfolding is screwed up - failWithTc (tyNameOutOfScope name) - } +tcLookupGlobal :: Name -> TcM TyThing +tcLookupGlobal name + = tcLookupGlobal_maybe name `thenM` \ maybe_thing -> + case maybe_thing of + Just thing -> returnM thing + other -> notFound "tcLookupGlobal" name + +tcLookupGlobalId :: Name -> TcM Id +tcLookupGlobalId name + = tcLookupGlobal_maybe name `thenM` \ maybe_thing -> + case maybe_thing of + Just (AnId id) -> returnM id + other -> notFound "tcLookupGlobal" name + +tcLookupDataCon :: Name -> TcM DataCon +tcLookupDataCon con_name + = tcLookupGlobalId con_name `thenM` \ con_id -> + case isDataConWrapId_maybe con_id of + Just data_con -> returnM data_con + Nothing -> failWithTc (badCon con_id) + +tcLookupClass :: Name -> TcM Class +tcLookupClass name + = tcLookupGlobal_maybe name `thenM` \ maybe_clas -> + case maybe_clas of + Just (AClass clas) -> returnM clas + other -> notFound "tcLookupClass" name -tcLookupClassByKey :: Unique -> NF_TcM s Class -tcLookupClassByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - case lookupUFM_Directly te key of - Just (_, AClass cl _) -> returnNF_Tc cl - other -> pprPanic "tcLookupClassByKey:" (pprUnique10 key) - -tcLookupClassByKey_maybe :: Unique -> NF_TcM s (Maybe Class) -tcLookupClassByKey_maybe key - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - case lookupUFM_Directly te key of - Just (_, AClass cl _) -> returnNF_Tc (Just cl) - other -> returnNF_Tc Nothing - -tcLookupTyConByKey :: Unique -> NF_TcM s TyCon -tcLookupTyConByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - case lookupUFM_Directly te key of - Just (_, ADataTyCon tc) -> returnNF_Tc tc - Just (_, ASynTyCon tc _) -> returnNF_Tc tc - other -> pprPanic "tcLookupTyConByKey:" (pprUnique10 key) -\end{code} +tcLookupTyCon :: Name -> TcM TyCon +tcLookupTyCon name + = tcLookupGlobal_maybe name `thenM` \ maybe_tc -> + case maybe_tc of + Just (ATyCon tc) -> returnM tc + other -> notFound "tcLookupTyCon" name +getInGlobalScope :: TcRn m (Name -> Bool) +getInGlobalScope = do { gbl_env <- getGblEnv ; + return (\n -> isJust (lookup_global gbl_env n)) } +\end{code} %************************************************************************ %* * -\subsection{The value environment} +\subsection{The local environment} %* * %************************************************************************ \begin{code} -tcExtendGlobalValEnv :: [Id] -> TcM s a -> TcM s a -tcExtendGlobalValEnv ids scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - let - ve' = addListToUFM_Directly ve [(getUnique id, id) | id <- ids] - in - tcSetEnv (TcEnv ue te ve' ie gtvs) scope +tcLookup_maybe :: Name -> TcM (Maybe TcTyThing) +tcLookup_maybe name + = 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 `thenM` \ maybe_thing -> + case maybe_thing of + Just thing -> returnM thing + other -> notFound "tcLookup" name + -- Extract the IdInfo from an IfaceSig imported from an interface file -tcExtendLocalValEnv :: [(Name,TcId)] -> TcM s a -> TcM s a -tcExtendLocalValEnv names_w_ids scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (in_scope_tvs,gtvs)) -> - tcReadMutVar gtvs `thenNF_Tc` \ global_tvs -> - let - ve' = extendNameEnv 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 ue te ve' ie (in_scope_tvs,gtvs')) scope +tcLookupId :: Name -> TcM Id +-- Used when we aren't interested in the binding level +tcLookupId name + = tcLookup name `thenM` \ thing -> + case thing of + ATcId tc_id lvl -> returnM tc_id + AGlobal (AnId id) -> returnM id + other -> pprPanic "tcLookupId" (ppr name) + +tcLookupIdLvl :: Name -> TcM (Id, Level) +tcLookupIdLvl name + = tcLookup name `thenM` \ thing -> + case thing of + ATcId tc_id lvl -> returnM (tc_id, lvl) + AGlobal (AnId id) -> returnM (id, impLevel) + other -> pprPanic "tcLookupIdLvl" (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) (metaLevel (tcl_level 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) + +getLclEnvElts :: TcM [TcTyThing] +getLclEnvElts = getLclEnv `thenM` \ env -> + return (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} -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 ue te ve ie gtvs) -> - returnNF_Tc (lookupWithDefaultUFM ve def name) +tcExtendKindEnv :: [(Name,TcKind)] -> TcM r -> TcM r +tcExtendKindEnv pairs thing_inside + = updLclEnv upd thing_inside 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 ue te ve ie gtvs) -> - returnNF_Tc (lookupNameEnv ve name) - -tcLookupValueByKey :: Unique -> NF_TcM s Id -- Panics if not found -tcLookupValueByKey key - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - returnNF_Tc (explicitLookupValueByKey ve key) - -tcLookupValueByKeyMaybe :: Unique -> NF_TcM s (Maybe Id) -tcLookupValueByKeyMaybe key - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - returnNF_Tc (lookupUFM_Directly ve key) - -tcGetValueEnv :: NF_TcM s ValueEnv -tcGetValueEnv - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie gtvs) -> - returnNF_Tc ve - - -tcSetValueEnv :: ValueEnv -> TcM s a -> TcM s a -tcSetValueEnv ve scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te _ ie gtvs) -> - tcSetEnv (TcEnv ue te ve ie 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 -> lookupNameEnv 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 `lazySetIdInfo` new_info - -- The Id must be returned without a data dependency on maybe_id - 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 + 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 + +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}) -> + let + le' = extendNameEnvList le 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 ... + -- 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'}) thing_inside \end{code} -Constructing new Ids \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)) +tcExtendLocalValEnv :: [TcId] -> TcM a -> TcM a +tcExtendLocalValEnv ids thing_inside + = getLclEnv `thenM` \ env -> + let + extra_global_tyvars = tyVarsOfTypes [idType id | id <- ids] + lvl = metaLevel (tcl_level env) + extra_env = [(idName id, ATcId id 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] + lvl = metaLevel (tcl_level env) + extra_env = [(name, ATcId id lvl) | (name,id) <- names_w_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 \end{code} %************************************************************************ %* * -\subsection{The instance environment} +\subsection{The global tyvars} %* * %************************************************************************ \begin{code} -tcGetInstEnv :: NF_TcM s InstEnv -tcGetInstEnv = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve ie (_,gtvs)) -> - returnNF_Tc ie - -tcSetInstEnv :: InstEnv -> TcM s a -> TcM s a -tcSetInstEnv ie scope - = tcGetEnv `thenNF_Tc` \ (TcEnv ue te ve _ gtvs) -> - tcSetEnv (TcEnv ue te ve ie gtvs) scope -\end{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. +To improve subsequent calls to the same function it writes the zonked set back into +the environment. \begin{code} -type InstEnv = UniqFM ClsInstEnv -- Maps Class to instances for that class -type ClsInstEnv = [(TyVarSet, [Type], Id)] -- The instances for a particular class - -classInstEnv :: InstEnv -> Class -> ClsInstEnv -classInstEnv env cls = lookupWithDefaultUFM env [] cls +tcGetGlobalTyVars :: TcM TcTyVarSet +tcGetGlobalTyVars + = 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} -A @ClsInstEnv@ lives inside a class, and identifies all the instances -of that class. The @Id@ inside a ClsInstEnv mapping is the dfun for -that instance. - -If class C maps to a list containing the item ([a,b], [t1,t2,t3], dfun), then - - forall a b, C t1 t2 t3 can be constructed by dfun - -or, to put it another way, we have - - instance (...) => C t1 t2 t3, witnessed by dfun - -There is an important consistency constraint in the elements of a ClsInstEnv: - - * [a,b] must be a superset of the free vars of [t1,t2,t3] - - * The dfun must itself be quantified over [a,b] - -Thus, the @ClassInstEnv@ for @Eq@ might contain the following entry: - [a] ===> dfun_Eq_List :: forall a. Eq a => Eq [a] -The "a" in the pattern must be one of the forall'd variables in -the dfun type. - - - -Notes on overlapping instances -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -In some ClsInstEnvs, overlap is prohibited; that is, no pair of templates unify. - -In others, overlap is permitted, but only in such a way that one can make -a unique choice when looking up. That is, overlap is only permitted if -one template matches the other, or vice versa. So this is ok: - - [a] [Int] - -but this is not - - (Int,a) (b,Int) - -If overlap is permitted, the list is kept most specific first, so that -the first lookup is the right choice. - -For now we just use association lists. - -\subsection{Avoiding a problem with overlapping} - -Consider this little program: - -\begin{pseudocode} - class C a where c :: a - class C a => D a where d :: a - - instance C Int where c = 17 - instance D Int where d = 13 - - instance C a => C [a] where c = [c] - instance ({- C [a], -} D a) => D [a] where d = c - - instance C [Int] where c = [37] - - main = print (d :: [Int]) -\end{pseudocode} - -What do you think `main' prints (assuming we have overlapping instances, and -all that turned on)? Well, the instance for `D' at type `[a]' is defined to -be `c' at the same type, and we've got an instance of `C' at `[Int]', so the -answer is `[37]', right? (the generic `C [a]' instance shouldn't apply because -the `C [Int]' instance is more specific). - -Ghc-4.04 gives `[37]', while ghc-4.06 gives `[17]', so 4.06 is wrong. That -was easy ;-) Let's just consult hugs for good measure. Wait - if I use old -hugs (pre-September99), I get `[17]', and stranger yet, if I use hugs98, it -doesn't even compile! What's going on!? - -What hugs complains about is the `D [a]' instance decl. - -\begin{pseudocode} - ERROR "mj.hs" (line 10): Cannot build superclass instance - *** Instance : D [a] - *** Context supplied : D a - *** Required superclass : C [a] -\end{pseudocode} +%************************************************************************ +%* * +\subsection{The instance environment} +%* * +%************************************************************************ -You might wonder what hugs is complaining about. It's saying that you -need to add `C [a]' to the context of the `D [a]' instance (as appears -in comments). But there's that `C [a]' instance decl one line above -that says that I can reduce the need for a `C [a]' instance to the -need for a `C a' instance, and in this case, I already have the -necessary `C a' instance (since we have `D a' explicitly in the -context, and `C' is a superclass of `D'). +\begin{code} +tcGetInstEnv :: TcM InstEnv +tcGetInstEnv = getGblEnv `thenM` \ env -> + returnM (tcg_inst_env env) + +tcSetInstEnv :: InstEnv -> TcM a -> TcM a +tcSetInstEnv ie thing_inside + = getGblEnv `thenM` \ env -> + setGblEnv (env {tcg_inst_env = ie}) thing_inside + +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 + -- Extend the total inst-env with the new dfuns + (inst_env', errs) = extendInstEnv dflags (tcg_inst_env 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_inst_env = inst_env', + tcg_insts = lcl_dfuns ++ tcg_insts env } + + ; traceDFuns dfuns + ; addErrs errs + ; 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 + dfuns = map iDFunId infos + (inst_env', errs) = extendInstEnv dflags (tcg_inst_env env) dfuns + env' = env { tcg_inst_env = inst_env', + tcg_insts = dfuns ++ tcg_insts env } + ; traceDFuns dfuns + ; addErrs errs + ; setGblEnv env' thing_inside } + +traceDFuns dfuns + = traceTc (text "Adding instances:" <+> vcat (map pp dfuns)) + where + pp dfun = ppr dfun <+> dcolon <+> ppr (idType dfun) +\end{code} -Unfortunately, the above reasoning indicates a premature commitment to the -generic `C [a]' instance. I.e., it prematurely rules out the more specific -instance `C [Int]'. This is the mistake that ghc-4.06 makes. The fix is to -add the context that hugs suggests (uncomment the `C [a]'), effectively -deferring the decision about which instance to use. -Now, interestingly enough, 4.04 has this same bug, but it's covered up -in this case by a little known `optimization' that was disabled in -4.06. Ghc-4.04 silently inserts any missing superclass context into -an instance declaration. In this case, it silently inserts the `C -[a]', and everything happens to work out. +%************************************************************************ +%* * +\subsection{Rules} +%* * +%************************************************************************ -(See `basicTypes/MkId:mkDictFunId' for the code in question. Search for -`Mark Jones', although Mark claims no credit for the `optimization' in -question, and would rather it stopped being called the `Mark Jones -optimization' ;-) +\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} -So, what's the fix? I think hugs has it right. Here's why. Let's try -something else out with ghc-4.04. Let's add the following line: - d' :: D a => [a] - d' = c +%************************************************************************ +%* * +\subsection{The InstInfo type} +%* * +%************************************************************************ -Everyone raise their hand who thinks that `d :: [Int]' should give a -different answer from `d' :: [Int]'. Well, in ghc-4.04, it does. The -`optimization' only applies to instance decls, not to regular -bindings, giving inconsistent behavior. +The InstInfo type summarises the information in an instance declaration -Old hugs had this same bug. Here's how we fixed it: like GHC, the -list of instances for a given class is ordered, so that more specific -instances come before more generic ones. For example, the instance -list for C might contain: - ..., C Int, ..., C a, ... -When we go to look for a `C Int' instance we'll get that one first. -But what if we go looking for a `C b' (`b' is unconstrained)? We'll -pass the `C Int' instance, and keep going. But if `b' is -unconstrained, then we don't know yet if the more specific instance -will eventually apply. GHC keeps going, and matches on the generic `C -a'. The fix is to, at each step, check to see if there's a reverse -match, and if so, abort the search. This prevents hugs from -prematurely chosing a generic instance when a more specific one -exists. + instance c => k (t tvs) where b ---Jeff +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} -emptyInstEnv :: InstEnv -emptyInstEnv = emptyUFM -\end{code} +data InstInfo + = InstInfo { + iDFunId :: DFunId, -- The dfun id + iBinds :: InstBindings + } -@lookupInstEnv@ looks up in a @InstEnv@, using a one-way match. Since -the env is kept ordered, the first match must be the only one. The -thing we are looking up can have an arbitrary "flexi" part. +data InstBindings + = VanillaInst -- The normal case + RenamedMonoBinds -- Bindings + [RenamedSig] -- User pragmas recorded for generating + -- specialised instances -\begin{code} -lookupInstEnv :: InstEnv -- The envt - -> Class -> [Type] -- Key - -> InstLookupResult - -data InstLookupResult - = FoundInst -- There is a (template,substitution) pair - -- that makes the template match the key, - -- and no template is an instance of the key - TyVarSubstEnv Id - - | NoMatch Bool -- Boolean is true iff there is at least one - -- template that matches the key. - -- (but there are other template(s) that are - -- instances of the key, so we don't report - -- FoundInst) - -- The NoMatch True case happens when we look up - -- Foo [a] - -- in an InstEnv that has entries for - -- Foo [Int] - -- Foo [b] - -- Then which we choose would depend on the way in which 'a' - -- is instantiated. So we say there is no match, but identify - -- it as ambiguous case in the hope of giving a better error msg. - -- See the notes above from Jeff Lewis - -lookupInstEnv env key_cls key_tys - = find (classInstEnv env key_cls) - where - key_vars = tyVarsOfTypes key_tys - - find [] = NoMatch False - find ((tpl_tyvars, tpl, val) : rest) - = case matchTys tpl_tyvars tpl key_tys of - Nothing -> - case matchTys key_vars key_tys tpl of - Nothing -> find rest - Just (_, _) -> NoMatch (any_match rest) - Just (subst, leftovers) -> ASSERT( null leftovers ) - FoundInst subst val - - any_match rest = or [ maybeToBool (matchTys tvs tpl key_tys) - | (tvs,tpl,_) <- rest - ] -\end{code} + | 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 -@addToClsInstEnv@ extends a @ClsInstEnv@, checking for overlaps. +pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info))] -A boolean flag controls overlap reporting. +pprInstInfoDetails (InstInfo { iBinds = VanillaInst b _ }) = ppr b +pprInstInfoDetails (InstInfo { iBinds = NewTypeDerived _}) = text "Derived from the representation type" -True => overlap is permitted, but only if one template matches the other; - not if they unify but neither is +simpleInstInfoTy :: InstInfo -> Type +simpleInstInfoTy info = case tcSplitDFunTy (idType (iDFunId info)) of + (_, _, _, [ty]) -> ty -\begin{code} -addToInstEnv :: Bool -- True <=> overlap permitted - -> InstEnv -- Envt - -> Class -> [TyVar] -> [Type] -> Id -- New item - -> MaybeErr InstEnv -- Success... - ([Type], Id) -- Failure: Offending overlap - -addToInstEnv overlap_ok inst_env clas ins_tvs ins_tys value - = case insert_into (classInstEnv inst_env clas) of - Failed stuff -> Failed stuff - Succeeded new_env -> Succeeded (addToUFM inst_env clas new_env) - - where - ins_tv_set = mkVarSet ins_tvs - ins_item = (ins_tv_set, ins_tys, value) - - insert_into [] = returnMaB [ins_item] - insert_into env@(cur_item@(tpl_tvs, tpl_tys, val) : rest) - - -- FAIL if: - -- (a) they are the same, or - -- (b) they unify, and any sort of overlap is prohibited, - -- (c) they unify but neither is more specific than t'other - | identical - || (unifiable && not overlap_ok) - || (unifiable && not (ins_item_more_specific || cur_item_more_specific)) - = failMaB (tpl_tys, val) - - -- New item is an instance of current item, so drop it here - | ins_item_more_specific = returnMaB (ins_item : env) - - -- Otherwise carry on - | otherwise = insert_into rest `thenMaB` \ rest' -> - returnMaB (cur_item : rest') - where - unifiable = maybeToBool (unifyTyListsX (ins_tv_set `unionVarSet` tpl_tvs) tpl_tys ins_tys) - ins_item_more_specific = maybeToBool (matchTys tpl_tvs tpl_tys ins_tys) - cur_item_more_specific = maybeToBool (matchTys ins_tv_set ins_tys tpl_tys) - identical = ins_item_more_specific && cur_item_more_specific +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} - %************************************************************************ %* * \subsection{Errors} @@ -741,14 +611,8 @@ addToInstEnv overlap_ok inst_env clas ins_tvs ins_tys value %************************************************************************ \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") - -uvNameOutOfScope name - = ptext SLIT("UVar") <+> quotes (ppr name) <+> ptext SLIT("is not in scope") +badCon con_id = quotes (ppr con_id) <+> ptext SLIT("is not a data constructor") -tyNameOutOfScope name - = quotes (ppr name) <+> ptext SLIT("is not in scope") +notFound wheRe name = failWithTc (text wheRe <> colon <+> quotes (ppr name) <+> + ptext SLIT("is not in scope")) \end{code}