X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcTyClsDecls.lhs;h=6e4e0d6763d7cc9af80af6343644ec34ff77eeb6;hb=cae34044d89a87bd3da83b0e867b4a5d6994079a;hp=fce676f4494037649725541c463c7e171855ed4d;hpb=ca5a4a480d10d61e5b7a52eb4d556e8b8c33e69d;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcTyClsDecls.lhs b/ghc/compiler/typecheck/TcTyClsDecls.lhs index fce676f..6e4e0d6 100644 --- a/ghc/compiler/typecheck/TcTyClsDecls.lhs +++ b/ghc/compiler/typecheck/TcTyClsDecls.lhs @@ -1,338 +1,504 @@ % -% (c) The AQUA Project, Glasgow University, 1996 +% (c) The AQUA Project, Glasgow University, 1996-1998 % \section[TcTyClsDecls]{Typecheck type and class declarations} \begin{code} -#include "HsVersions.h" - module TcTyClsDecls ( - tcTyAndClassDecls1 + tcTyAndClassDecls ) where -import Ubiq{-uitous-} +#include "HsVersions.h" -import HsSyn ( TyDecl(..), ConDecl(..), BangType(..), - ClassDecl(..), MonoType(..), PolyType(..), - Sig(..), MonoBinds, Fake, InPat, HsBinds(..), Bind, HsExpr ) -import RnHsSyn ( isRnTyCon, RenamedTyDecl(..), RenamedClassDecl(..), - RnName(..){-instance Uniquable-} +import HsSyn ( HsDecl(..), TyClDecl(..), + HsType(..), HsTyVarBndr, + ConDecl(..), ConDetails(..), BangType(..), + Sig(..), HsPred(..), HsTupCon(..), + tyClDeclName, hsTyVarNames, isClassDecl, isSynDecl, isClassOpSig, getBangType ) -import TcHsSyn ( TcHsBinds(..), TcIdOcc(..) ) +import RnHsSyn ( RenamedHsDecl, RenamedTyClDecl, listTyCon_name ) +import BasicTypes ( RecFlag(..), NewOrData(..), Arity ) -import TcMonad hiding ( rnMtoTcM ) -import Inst ( InstanceMapper(..) ) +import TcMonad +import TcEnv ( ValueEnv, TyThing(..), TyThingDetails(..), tyThingKind, + tcExtendTypeEnv, tcExtendKindEnv, tcLookupTy + ) +import TcTyDecls ( tcTyDecl1, kcConDetails, mkNewTyConRep ) import TcClassDcl ( tcClassDecl1 ) -import TcEnv ( tcExtendTyConEnv, tcExtendClassEnv, - tcExtendGlobalValEnv, - tcTyVarScope, tcGetEnv ) -import TcKind ( TcKind, newKindVars ) -import TcTyDecls ( tcTyDecl, mkDataBinds ) - +import TcMonoType ( kcHsTyVars, kcHsType, kcHsBoxedSigType, kcHsContext, mkTyClTyVars ) +import TcType ( TcKind, newKindVar, newKindVars, zonkKindEnv ) + +import TcUnify ( unifyKind ) +import Type ( Kind, mkArrowKind, boxedTypeKind, zipFunTys ) +import Variance ( calcTyConArgVrcs ) +import Class ( Class, mkClass, classTyCon ) +import TyCon ( TyCon, ArgVrcs, AlgTyConFlavour(..), mkSynTyCon, mkAlgTyCon, mkClassTyCon ) +import DataCon ( isNullaryDataCon ) +import Var ( TyVar, tyVarKind, varName ) +import VarEnv +import FiniteMap import Bag -import Class ( Class(..), classSelIds ) -import Digraph ( findSCCs, SCC(..) ) -import Name ( getSrcLoc ) -import PprStyle -import Pretty -import UniqSet ( UniqSet(..), emptyUniqSet, +import Digraph ( stronglyConnComp, SCC(..) ) +import Name ( Name, NamedThing(..), NameEnv, getSrcLoc, isTvOcc, nameOccName, + mkNameEnv, lookupNameEnv_NF + ) +import Outputable +import Maybes ( mapMaybe, catMaybes ) +import UniqSet ( UniqSet, emptyUniqSet, unitUniqSet, unionUniqSets, unionManyUniqSets, uniqSetToList ) -import SrcLoc ( SrcLoc ) -import TyCon ( TyCon, tyConDataCons, isDataTyCon, isSynTyCon ) -import Unique ( Unique ) -import Util ( panic, pprTrace ) - +import ErrUtils ( Message ) +import Unique ( Unique, Uniquable(..) ) \end{code} + +%************************************************************************ +%* * +\subsection{Type checking for type and class declarations} +%* * +%************************************************************************ + The main function ~~~~~~~~~~~~~~~~~ \begin{code} -data Decl = TyD RenamedTyDecl | ClD RenamedClassDecl +tcTyAndClassDecls :: ValueEnv -- Knot tying stuff + -> [RenamedHsDecl] + -> TcM s TcEnv + +tcTyAndClassDecls unf_env decls + = sortByDependency decls `thenTc` \ groups -> + tcGroups unf_env groups + +tcGroups unf_env [] + = tcGetEnv `thenNF_Tc` \ env -> + returnTc env + +tcGroups unf_env (group:groups) + = tcGroup unf_env group `thenTc` \ env -> + tcSetEnv env $ + tcGroups unf_env groups +\end{code} -tcTyAndClassDecls1 :: InstanceMapper - -> Bag RenamedTyDecl -> Bag RenamedClassDecl - -> TcM s (TcEnv s, TcHsBinds s) +Dealing with a group +~~~~~~~~~~~~~~~~~~~~ -tcTyAndClassDecls1 inst_mapper rnty_decls rncls_decls - = sortByDependency syn_decls cls_decls decls `thenTc` \ groups -> - tcGroups inst_mapper groups - where - cls_decls = mapBag ClD rncls_decls - ty_decls = mapBag TyD rnty_decls - syn_decls = filterBag is_syn_decl ty_decls - decls = ty_decls `unionBags` cls_decls +Consider a mutually-recursive group, binding +a type constructor T and a class C. + +Step 1: getInitialKind + Construct a KindEnv by binding T and C to a kind variable + +Step 2: kcTyClDecl + In that environment, do a kind check - is_syn_decl (TyD (TySynonym _ _ _ _)) = True - is_syn_decl _ = False +Step 3: Zonk the kinds -tcGroups inst_mapper [] - = tcGetEnv `thenNF_Tc` \ env -> - returnTc (env, EmptyBinds) +Step 4: buildTyConOrClass + Construct an environment binding T to a TyCon and C to a Class. + a) Their kinds comes from zonking the relevant kind variable + b) Their arity (for synonyms) comes direct from the decl + c) The funcional dependencies come from the decl + d) The rest comes a knot-tied binding of T and C, returned from Step 4 + e) The variances of the tycons in the group is calculated from + the knot-tied stuff -tcGroups inst_mapper (group:groups) - = tcGroup inst_mapper group `thenTc` \ (new_env, binds1) -> +Step 5: tcTyClDecl1 + In this environment, walk over the decls, constructing the TyCons and Classes. + This uses in a strict way items (a)-(c) above, which is why they must + be constructed in Step 4. + Feed the results back to Step 4. + +The knot-tying parameters: @rec_details_list@ is an alist mapping @Name@s to +@TyThing@s. @rec_vrcs@ is a finite map from @Name@s to @ArgVrcs@s. - -- Extend the environment using the new tycons and classes - tcSetEnv new_env $ +\begin{code} +tcGroup :: ValueEnv -> SCC RenamedTyClDecl -> TcM s TcEnv +tcGroup unf_env scc + = -- Step 1 + mapNF_Tc getInitialKind decls `thenNF_Tc` \ initial_kinds -> + + -- Step 2 + tcExtendKindEnv initial_kinds (mapTc kcTyClDecl decls) `thenTc_` + + -- Step 3 + zonkKindEnv initial_kinds `thenNF_Tc` \ final_kinds -> + + -- Tie the knot + fixTc ( \ ~(rec_details_list, _) -> + -- Step 4 + let + kind_env = mkNameEnv final_kinds + rec_details = mkNameEnv rec_details_list + + tyclss, all_tyclss :: [(Name, TyThing)] + tyclss = map (buildTyConOrClass is_rec kind_env rec_vrcs rec_details) decls + + -- Add the tycons that come from the classes + -- We want them in the environment because + -- they are mentioned in interface files + all_tyclss = [ (getName tycon, ATyCon tycon) | (_, AClass clas) <- tyclss, + let tycon = classTyCon clas + ] ++ tyclss + + -- Calculate variances, and (yes!) feed back into buildTyConOrClass. + rec_vrcs = calcTyConArgVrcs [tc | (_, ATyCon tc) <- all_tyclss] + in + -- Step 5 + tcExtendTypeEnv all_tyclss $ + mapTc (tcTyClDecl1 unf_env) decls `thenTc` \ tycls_details -> + tcGetEnv `thenNF_Tc` \ env -> + returnTc (tycls_details, env) + ) `thenTc` \ (_, env) -> + returnTc env + where + is_rec = case scc of + AcyclicSCC _ -> NonRecursive + CyclicSCC _ -> Recursive - -- Do the remaining groups - tcGroups inst_mapper groups `thenTc` \ (final_env, binds2) -> + decls = case scc of + AcyclicSCC decl -> [decl] + CyclicSCC decls -> decls - returnTc (final_env, binds1 `ThenBinds` binds2) +tcTyClDecl1 :: ValueEnv -> RenamedTyClDecl -> TcM s (Name, TyThingDetails) + +tcTyClDecl1 unf_env decl + | isClassDecl decl = tcClassDecl1 unf_env decl + | otherwise = tcTyDecl1 decl \end{code} -Dealing with a group -~~~~~~~~~~~~~~~~~~~~ -\begin{code} -tcGroup :: InstanceMapper -> Bag Decl -> TcM s (TcEnv s, TcHsBinds s) -tcGroup inst_mapper decls - = --pprTrace "tcGroup: " (ppCat (map (fst.fmt_decl) (bagToList decls))) $ - - -- TIE THE KNOT - fixTc ( \ ~(tycons,classes,_) -> - - -- EXTEND TYPE AND CLASS ENVIRONMENTS - -- including their data constructors and class operations - -- NB: it's important that the tycons and classes come back in just - -- the same order from this fix as from get_binders, so that these - -- extend-env things work properly. A bit UGH-ish. - tcExtendTyConEnv tycon_names_w_arities tycons $ - tcExtendClassEnv class_names classes $ - - -- DEAL WITH TYPE VARIABLES - tcTyVarScope tyvar_names ( \ tyvars -> - - -- DEAL WITH THE DEFINITIONS THEMSELVES - foldBag combine (tcDecl inst_mapper) - (returnTc (emptyBag, emptyBag)) - decls - ) `thenTc` \ (tycon_bag,class_bag) -> - let - tycons = bagToList tycon_bag - classes = bagToList class_bag - in - - -- SNAFFLE ENV TO RETURN - tcGetEnv `thenNF_Tc` \ final_env -> - - returnTc (tycons, classes, final_env) - ) `thenTc` \ (tycons, classes, final_env) -> - - - -- Create any necessary record selector Ids and their bindings - -- "Necessary" includes data and newtype declarations - mapAndUnzipTc mkDataBinds (filter (not.isSynTyCon) tycons) `thenTc` \ (data_ids_s, binds) -> - - -- Extend the global value environment with - -- a) constructors - -- b) record selectors - -- c) class op selectors - tcSetEnv final_env $ - tcExtendGlobalValEnv (concat data_ids_s) $ - tcExtendGlobalValEnv (concat (map classSelIds classes)) $ - tcGetEnv `thenNF_Tc` \ really_final_env -> +%************************************************************************ +%* * +\subsection{Step 1: Initial environment} +%* * +%************************************************************************ - returnTc (really_final_env, foldr ThenBinds EmptyBinds binds) +\begin{code} +getInitialKind :: RenamedTyClDecl -> NF_TcM s (Name, TcKind) +getInitialKind (TySynonym name tyvars _ _) + = kcHsTyVars tyvars `thenNF_Tc` \ arg_kinds -> + newKindVar `thenNF_Tc` \ result_kind -> + returnNF_Tc (name, mk_kind arg_kinds result_kind) - where - (tyvar_rn_names, tycon_names_w_arities, class_names) = get_binders decls +getInitialKind (TyData _ _ name tyvars _ _ _ _ _) + = kcHsTyVars tyvars `thenNF_Tc` \ arg_kinds -> + returnNF_Tc (name, mk_kind arg_kinds boxedTypeKind) - tyvar_names = map de_rn tyvar_rn_names - de_rn (RnName n) = n +getInitialKind (ClassDecl _ name tyvars _ _ _ _ _ _ _ _ _) + = kcHsTyVars tyvars `thenNF_Tc` \ arg_kinds -> + returnNF_Tc (name, mk_kind arg_kinds boxedTypeKind) - combine do_a do_b - = do_a `thenTc` \ (a1,a2) -> - do_b `thenTc` \ (b1,b2) -> - returnTc (a1 `unionBags` b1, a2 `unionBags` b2) +mk_kind tvs_w_kinds res_kind = foldr (mkArrowKind . snd) res_kind tvs_w_kinds \end{code} -Dealing with one decl -~~~~~~~~~~~~~~~~~~~~~ + +%************************************************************************ +%* * +\subsection{Step 2: Kind checking} +%* * +%************************************************************************ + +We need to kind check all types in the mutually recursive group +before we know the kind of the type variables. For example: + +class C a where + op :: D b => a -> b -> b + +class D c where + bop :: (Monad c) => ... + +Here, the kind of the locally-polymorphic type variable "b" +depends on *all the uses of class D*. For example, the use of +Monad c in bop's type signature means that D must have kind Type->Type. + \begin{code} -tcDecl :: InstanceMapper - -> Decl - -> TcM s (Bag TyCon, Bag Class) +kcTyClDecl :: RenamedTyClDecl -> TcM s () + +kcTyClDecl decl@(TySynonym tycon_name hs_tyvars rhs loc) + = tcAddDeclCtxt decl $ + kcTyClDeclBody tycon_name hs_tyvars $ \ result_kind -> + kcHsType rhs `thenTc` \ rhs_kind -> + unifyKind result_kind rhs_kind + +kcTyClDecl decl@(TyData _ context tycon_name hs_tyvars con_decls _ _ _ loc) + = tcAddDeclCtxt decl $ + kcTyClDeclBody tycon_name hs_tyvars $ \ result_kind -> + kcHsContext context `thenTc_` + mapTc_ kc_con_decl con_decls + where + kc_con_decl (ConDecl _ _ ex_tvs ex_ctxt details loc) + = tcAddSrcLoc loc $ + kcHsTyVars ex_tvs `thenNF_Tc` \ kind_env -> + tcExtendKindEnv kind_env $ + kcConDetails ex_ctxt details + +kcTyClDecl decl@(ClassDecl context class_name + hs_tyvars fundeps class_sigs + _ _ _ _ _ _ loc) + = tcAddDeclCtxt decl $ + kcTyClDeclBody class_name hs_tyvars $ \ result_kind -> + kcHsContext context `thenTc_` + mapTc_ kc_sig (filter isClassOpSig class_sigs) + where + kc_sig (ClassOpSig _ _ op_ty loc) = tcAddSrcLoc loc (kcHsBoxedSigType op_ty) + +kcTyClDeclBody :: Name -> [HsTyVarBndr Name] -- Kind of the tycon/cls and its tyvars + -> (Kind -> TcM s a) -- Thing inside + -> TcM s a +-- Extend the env with bindings for the tyvars, taken from +-- the kind of the tycon/class. Give it to the thing inside, and +-- check the result kind matches +kcTyClDeclBody tc_name hs_tyvars thing_inside + = tcLookupTy tc_name `thenNF_Tc` \ tc -> + let + (tyvars_w_kinds, result_kind) = zipFunTys (hsTyVarNames hs_tyvars) (tyThingKind tc) + in + tcExtendKindEnv tyvars_w_kinds (thing_inside result_kind) +\end{code} -tcDecl inst_mapper (TyD decl) - = tcTyDecl decl `thenTc` \ tycon -> - returnTc (unitBag tycon, emptyBag) -tcDecl inst_mapper (ClD decl) - = tcClassDecl1 inst_mapper decl `thenTc` \ clas -> - returnTc (emptyBag, unitBag clas) +%************************************************************************ +%* * +\subsection{Step 4: Building the tycon/class} +%* * +%************************************************************************ + +\begin{code} +buildTyConOrClass + :: RecFlag -> NameEnv Kind + -> FiniteMap TyCon ArgVrcs -> NameEnv TyThingDetails + -> RenamedTyClDecl -> (Name, TyThing) + -- Can't fail; the only reason it's in the monad + -- is so it can zonk the kinds + +buildTyConOrClass is_rec kenv rec_vrcs rec_details + (TySynonym tycon_name tyvar_names rhs src_loc) + = (tycon_name, ATyCon tycon) + where + tycon = mkSynTyCon tycon_name tycon_kind arity tyvars rhs_ty argvrcs + tycon_kind = lookupNameEnv_NF kenv tycon_name + arity = length tyvar_names + tyvars = mkTyClTyVars tycon_kind tyvar_names + SynTyDetails rhs_ty = lookupNameEnv_NF rec_details tycon_name + argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon + +buildTyConOrClass is_rec kenv rec_vrcs rec_details + (TyData data_or_new context tycon_name tyvar_names _ nconstrs _ _ src_loc) + = (tycon_name, ATyCon tycon) + where + tycon = mkAlgTyCon tycon_name tycon_kind tyvars ctxt argvrcs + data_cons nconstrs + derived_classes + flavour is_rec + + DataTyDetails ctxt data_cons derived_classes = lookupNameEnv_NF rec_details tycon_name + + tycon_kind = lookupNameEnv_NF kenv tycon_name + tyvars = mkTyClTyVars tycon_kind tyvar_names + argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon + + flavour = case data_or_new of + NewType -> NewTyCon (mkNewTyConRep tycon) + DataType | all isNullaryDataCon data_cons -> EnumTyCon + | otherwise -> DataTyCon + +buildTyConOrClass is_rec kenv rec_vrcs rec_details + (ClassDecl context class_name + tyvar_names fundeps class_sigs def_methods pragmas + tycon_name datacon_name datacon_wkr_name sc_sel_names src_loc) + = (class_name, AClass clas) + where + clas = mkClass class_name tyvars fds + sc_theta sc_sel_ids op_items + tycon + + tycon = mkClassTyCon tycon_name class_kind tyvars + argvrcs dict_con + clas -- Yes! It's a dictionary + flavour + + ClassDetails sc_theta sc_sel_ids op_items dict_con = lookupNameEnv_NF rec_details class_name + + class_kind = lookupNameEnv_NF kenv class_name + tyvars = mkTyClTyVars class_kind tyvar_names + argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon + n_fields = length sc_sel_ids + length op_items + + flavour | n_fields == 1 = NewTyCon (mkNewTyConRep tycon) + | otherwise = DataTyCon + + -- We can find the functional dependencies right away, + -- and it is vital to do so. Why? Because in the next pass + -- we check for ambiguity in all the type signatures, and we + -- need the functional dependcies to be done by then + fds = [(map lookup xs, map lookup ys) | (xs,ys) <- fundeps] + tyvar_env = mkNameEnv [(varName tv, tv) | tv <- tyvars] + lookup = lookupNameEnv_NF tyvar_env + +bogusVrcs = panic "Bogus tycon arg variances" \end{code} + +%************************************************************************ +%* * +\subsection{Dependency analysis} +%* * +%************************************************************************ + Dependency analysis ~~~~~~~~~~~~~~~~~~~ \begin{code} -sortByDependency :: Bag Decl -> Bag Decl -> Bag Decl -> TcM s [Bag Decl] -sortByDependency syn_decls cls_decls decls - = let -- CHECK FOR SYNONYM CYCLES - syn_sccs = findSCCs mk_edges syn_decls - syn_cycles = [map fmt_decl (bagToList decls) - | CyclicSCC decls <- syn_sccs] - +sortByDependency :: [RenamedHsDecl] -> TcM s [SCC RenamedTyClDecl] +sortByDependency decls + = let -- CHECK FOR CLASS CYCLES + cls_sccs = stronglyConnComp (mapMaybe mk_cls_edges tycl_decls) + cls_cycles = [ decls | CyclicSCC decls <- cls_sccs] in - checkTc (null syn_cycles) (typeCycleErr syn_cycles) `thenTc_` + checkTc (null cls_cycles) (classCycleErr cls_cycles) `thenTc_` - let -- CHECK FOR CLASS CYCLES - cls_sccs = findSCCs mk_edges cls_decls - cls_cycles = [map fmt_decl (bagToList decls) - | CyclicSCC decls <- cls_sccs] + let -- CHECK FOR SYNONYM CYCLES + syn_sccs = stronglyConnComp (filter is_syn_decl edges) + syn_cycles = [ decls | CyclicSCC decls <- syn_sccs] in - checkTc (null cls_cycles) (classCycleErr cls_cycles) `thenTc_` + checkTc (null syn_cycles) (typeCycleErr syn_cycles) `thenTc_` - -- DO THE MAIN DEPENDENCY ANALYSIS + -- DO THE MAIN DEPENDENCY ANALYSIS let - decl_sccs = findSCCs mk_edges decls - scc_bags = map bag_acyclic decl_sccs + decl_sccs = stronglyConnComp edges in - returnTc (scc_bags) - - where - bag_acyclic (AcyclicSCC scc) = unitBag scc - bag_acyclic (CyclicSCC sccs) = sccs - -fmt_decl decl - = (ppr PprForUser name, getSrcLoc name) + returnTc decl_sccs where - name = get_name decl - get_name (TyD (TyData _ name _ _ _ _ _)) = name - get_name (TyD (TyNew _ name _ _ _ _ _)) = name - get_name (TyD (TySynonym name _ _ _)) = name - get_name (ClD (ClassDecl _ name _ _ _ _ _)) = name + tycl_decls = [d | TyClD d <- decls] + edges = map mk_edges tycl_decls + + is_syn_decl (d, _, _) = isSynDecl d \end{code} Edges in Type/Class decls ~~~~~~~~~~~~~~~~~~~~~~~~~ -\begin{code} -mk_edges (TyD (TyData ctxt name _ condecls _ _ _)) - = (uniqueOf name, set_to_bag (get_ctxt ctxt `unionUniqSets` get_cons condecls)) -mk_edges (TyD (TyNew ctxt name _ condecl _ _ _)) - = (uniqueOf name, set_to_bag (get_ctxt ctxt `unionUniqSets` get_cons condecl)) -mk_edges (TyD (TySynonym name _ rhs _)) - = (uniqueOf name, set_to_bag (get_ty rhs)) -mk_edges (ClD (ClassDecl ctxt name _ sigs _ _ _)) - = (uniqueOf name, set_to_bag (get_ctxt ctxt `unionUniqSets` get_sigs sigs)) - -get_ctxt ctxt - = unionManyUniqSets (map (set_name.fst) ctxt) - -get_cons cons - = unionManyUniqSets (map get_con cons) - where - get_con (ConDecl _ btys _) - = unionManyUniqSets (map get_bty btys) - get_con (ConOpDecl bty1 _ bty2 _) - = unionUniqSets (get_bty bty1) (get_bty bty2) - get_con (NewConDecl _ ty _) - = get_ty ty - get_con (RecConDecl _ nbtys _) - = unionManyUniqSets (map (get_bty.snd) nbtys) - - get_bty (Banged ty) = get_pty ty - get_bty (Unbanged ty) = get_pty ty - -get_ty (MonoTyVar tv) - = emptyUniqSet -get_ty (MonoTyApp name tys) - = (if isRnTyCon name then set_name name else emptyUniqSet) - `unionUniqSets` get_tys tys -get_ty (MonoFunTy ty1 ty2) - = unionUniqSets (get_ty ty1) (get_ty ty2) -get_ty (MonoListTy ty) - = get_ty ty -- careful when defining [] (,,) etc as -get_ty (MonoTupleTy tys) -- [ty] (ty,ty,ty) will not give edges! - = get_tys tys -get_ty other = panic "TcTyClsDecls:get_ty" - -get_pty (HsForAllTy _ ctxt mty) - = get_ctxt ctxt `unionUniqSets` get_ty mty -get_pty other = panic "TcTyClsDecls:get_pty" - -get_tys tys - = unionManyUniqSets (map get_ty tys) +\begin{code} +---------------------------------------------------- +-- mk_cls_edges looks only at the context of class decls +-- Its used when we are figuring out if there's a cycle in the +-- superclass hierarchy + +mk_cls_edges :: RenamedTyClDecl -> Maybe (RenamedTyClDecl, Unique, [Unique]) + +mk_cls_edges decl@(ClassDecl ctxt name _ _ _ _ _ _ _ _ _ _) + = Just (decl, getUnique name, map getUnique (catMaybes (map get_clas ctxt))) +mk_cls_edges other_decl + = Nothing + +---------------------------------------------------- +mk_edges :: RenamedTyClDecl -> (RenamedTyClDecl, Unique, [Unique]) + +mk_edges decl@(TyData _ ctxt name _ condecls _ derivs _ _) + = (decl, getUnique name, uniqSetToList (get_ctxt ctxt `unionUniqSets` + get_cons condecls `unionUniqSets` + get_deriv derivs)) + +mk_edges decl@(TySynonym name _ rhs _) + = (decl, getUnique name, uniqSetToList (get_ty rhs)) + +mk_edges decl@(ClassDecl ctxt name _ _ sigs _ _ _ _ _ _ _) + = (decl, getUnique name, uniqSetToList (get_ctxt ctxt `unionUniqSets` + get_sigs sigs)) + + +---------------------------------------------------- +get_ctxt ctxt = unionManyUniqSets (map set_name (catMaybes (map get_clas ctxt))) +get_clas (HsPClass clas _) = Just clas +get_clas _ = Nothing + +---------------------------------------------------- +get_deriv Nothing = emptyUniqSet +get_deriv (Just clss) = unionManyUniqSets (map set_name clss) + +---------------------------------------------------- +get_cons cons = unionManyUniqSets (map get_con cons) + +---------------------------------------------------- +get_con (ConDecl _ _ _ ctxt details _) + = get_ctxt ctxt `unionUniqSets` get_con_details details + +---------------------------------------------------- +get_con_details (VanillaCon btys) = unionManyUniqSets (map get_bty btys) +get_con_details (InfixCon bty1 bty2) = unionUniqSets (get_bty bty1) (get_bty bty2) +get_con_details (RecCon nbtys) = unionManyUniqSets (map (get_bty.snd) nbtys) + +---------------------------------------------------- +get_bty bty = get_ty (getBangType bty) + +---------------------------------------------------- +get_ty (HsTyVar name) | isTvOcc (nameOccName name) = emptyUniqSet + | otherwise = set_name name +get_ty (HsAppTy ty1 ty2) = unionUniqSets (get_ty ty1) (get_ty ty2) +get_ty (HsFunTy ty1 ty2) = unionUniqSets (get_ty ty1) (get_ty ty2) +get_ty (HsListTy ty) = set_name listTyCon_name `unionUniqSets` get_ty ty +get_ty (HsTupleTy (HsTupCon n _) tys) = set_name n `unionUniqSets` get_tys tys +get_ty (HsUsgTy _ ty) = get_ty ty +get_ty (HsUsgForAllTy _ ty) = get_ty ty +get_ty (HsForAllTy _ ctxt mty) = get_ctxt ctxt `unionUniqSets` get_ty mty +get_ty (HsPredTy (HsPClass name _)) = set_name name +get_ty (HsPredTy (HsPIParam _ _)) = emptyUniqSet -- I think + +---------------------------------------------------- +get_tys tys = unionManyUniqSets (map get_ty tys) + +---------------------------------------------------- get_sigs sigs = unionManyUniqSets (map get_sig sigs) where - get_sig (ClassOpSig _ ty _ _) = get_pty ty + get_sig (ClassOpSig _ _ ty _) = get_ty ty + get_sig (FixSig _) = emptyUniqSet get_sig other = panic "TcTyClsDecls:get_sig" -set_name name = unitUniqSet (uniqueOf name) - +---------------------------------------------------- +set_name name = unitUniqSet (getUnique name) set_to_bag set = listToBag (uniqSetToList set) \end{code} -get_binders -~~~~~~~~~~~ -Extract *binding* names from type and class decls. Type variables are -bound in type, data, newtype and class declarations and the polytypes -in the class op sigs. - -Why do we need to grab all these type variables at once, including -those locally-quantified type variables in class op signatures? -Because we can only commit to the final kind of a type variable when -we've completed the mutually recursive group. For example: - -class C a where - op :: D b => a -> b -> b - -class D c where - bop :: (Monad c) => ... - -Here, the kind of the locally-polymorphic type variable "b" -depends on *all the uses of class D*. For example, the use of -Monad c in bop's type signature means that D must have kind Type->Type. - +%************************************************************************ +%* * +\subsection{Error management +%* * +%************************************************************************ \begin{code} -get_binders :: Bag Decl - -> ([RnName], -- TyVars; no dups - [(RnName, Maybe Arity)],-- Tycons; no dups; arities for synonyms - [RnName]) -- Classes; no dups - -get_binders decls = (bagToList tyvars, bagToList tycons, bagToList classes) +tcAddDeclCtxt decl thing_inside + = tcAddSrcLoc loc $ + tcAddErrCtxt ctxt $ + thing_inside where - (tyvars, tycons, classes) = foldBag union3 get_binders1 - (emptyBag,emptyBag,emptyBag) - decls - - union3 (a1,a2,a3) (b1,b2,b3) - = (a1 `unionBags` b1, a2 `unionBags` b2, a3 `unionBags` b3) - -get_binders1 (TyD (TyData _ name tyvars _ _ _ _)) - = (listToBag tyvars, unitBag (name,Nothing), emptyBag) -get_binders1 (TyD (TyNew _ name tyvars _ _ _ _)) - = (listToBag tyvars, unitBag (name,Nothing), emptyBag) -get_binders1 (TyD (TySynonym name tyvars _ _)) - = (listToBag tyvars, unitBag (name, Just (length tyvars)), emptyBag) -get_binders1 (ClD (ClassDecl _ name tyvar sigs _ _ _)) - = (unitBag tyvar `unionBags` sigs_tvs sigs, - emptyBag, unitBag name) - -sigs_tvs sigs = unionManyBags (map sig_tvs sigs) - where - sig_tvs (ClassOpSig _ ty _ _) = pty_tvs ty - pty_tvs (HsForAllTy tvs _ _) = listToBag tvs -- tvs doesn't include the class tyvar + (name, loc, thing) + = case decl of + (ClassDecl _ name _ _ _ _ _ _ _ _ _ loc) -> (name, loc, "class") + (TySynonym name _ _ loc) -> (name, loc, "type synonym") + (TyData NewType _ name _ _ _ _ _ loc) -> (name, loc, "data type") + (TyData DataType _ name _ _ _ _ _ loc) -> (name, loc, "newtype") + + ctxt = hsep [ptext SLIT("In the"), text thing, + ptext SLIT("declaration for"), quotes (ppr name)] \end{code} - \begin{code} -typeCycleErr syn_cycles sty - = ppAboves (map (pp_cycle sty "Cycle in type declarations ...") syn_cycles) +typeCycleErr, classCycleErr :: [[RenamedTyClDecl]] -> Message + +typeCycleErr syn_cycles + = vcat (map (pp_cycle "Cycle in type declarations:") syn_cycles) -classCycleErr cls_cycles sty - = ppAboves (map (pp_cycle sty "Cycle in class declarations ...") cls_cycles) +classCycleErr cls_cycles + = vcat (map (pp_cycle "Cycle in class declarations:") cls_cycles) -pp_cycle sty str things - = ppHang (ppStr str) - 4 (ppAboves (map pp_thing things)) +pp_cycle str decls + = hang (text str) + 4 (vcat (map pp_decl decls)) where - pp_thing (pp_name, loc) - = ppCat [pp_name, ppr sty loc] + pp_decl decl + = hsep [quotes (ppr name), ptext SLIT("at"), ppr (getSrcLoc name)] + where + name = tyClDeclName decl \end{code}