X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcTyClsDecls.lhs;h=5101ab316405fe829a1947ec2c8270f3ea5b10a3;hb=0171936c9092666692c69a7f93fa75af976330cb;hp=efcaa9de8f19cfdde760866f793d77b2be30685d;hpb=9dd6e1c216993624a2cd74b62ca0f0569c02c26b;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcTyClsDecls.lhs b/ghc/compiler/typecheck/TcTyClsDecls.lhs index efcaa9d..5101ab3 100644 --- a/ghc/compiler/typecheck/TcTyClsDecls.lhs +++ b/ghc/compiler/typecheck/TcTyClsDecls.lhs @@ -1,317 +1,517 @@ % -% (c) The AQUA Project, Glasgow University, 1996 +% (c) The AQUA Project, Glasgow University, 1996-1998 % \section[TcTyClsDecls]{Typecheck type and class declarations} \begin{code} module TcTyClsDecls ( - tcTyAndClassDecls1 + tcTyAndClassDecls ) where #include "HsVersions.h" -import HsSyn ( HsDecl(..), TyDecl(..), ClassDecl(..), - HsType(..), HsTyVar, - ConDecl(..), ConDetails(..), BangType(..), - Sig(..), - hsDeclName +import CmdLineOpts ( DynFlags, DynFlag(..), dopt ) +import HsSyn ( TyClDecl(..), + ConDecl(..), Sig(..), HsPred(..), + tyClDeclName, hsTyVarNames, tyClDeclTyVars, + isIfaceSigDecl, isClassDecl, isSynDecl, isClassOpSig ) -import RnHsSyn ( RenamedTyDecl(..), RenamedClassDecl(..), RenamedHsDecl ) -import TcHsSyn ( TcHsBinds ) -import BasicTypes ( RecFlag(..) ) +import RnHsSyn ( RenamedTyClDecl, tyClDeclFVs ) +import BasicTypes ( RecFlag(..), NewOrData(..) ) +import HscTypes ( implicitTyThingIds ) +import Module ( Module ) import TcMonad -import Inst ( InstanceMapper ) -import TcClassDcl ( tcClassDecl1 ) -import TcEnv ( TcIdOcc(..), tcExtendTyConEnv, tcExtendClassEnv ) -import TcKind ( TcKind, newKindVar, newKindVars, tcDefaultKind, kindToTcKind ) -import TcTyDecls ( tcTyDecl, mkDataBinds ) -import TcMonoType ( tcTyVarScope ) - -import TyCon ( tyConKind, tyConArity, isSynTyCon ) -import Class ( Class, classBigSig ) -import TyVar ( tyVarKind ) -import Bag +import TcEnv ( TcEnv, RecTcEnv, TcTyThing(..), TyThing(..), TyThingDetails(..), + tcExtendKindEnv, tcLookup, tcExtendGlobalEnv, + isLocalThing ) +import TcTyDecls ( tcTyDecl, kcConDetails, checkValidTyCon ) +import TcClassDcl ( tcClassDecl1, checkValidClass ) +import TcInstDcls ( tcAddDeclCtxt ) +import TcMonoType ( kcHsTyVars, kcHsType, kcHsLiftedSigType, kcHsContext, mkTyClTyVars ) +import TcMType ( newKindVar, zonkKindEnv ) +import TcUnify ( unifyKind ) +import TcType ( Type, Kind, TcKind, mkArrowKind, liftedTypeKind, zipFunTys ) +import Type ( splitTyConApp_maybe ) +import Variance ( calcTyConArgVrcs ) +import Class ( Class, mkClass, classTyCon ) +import TyCon ( TyCon, ArgVrcs, AlgTyConFlavour(..), DataConDetails(..), visibleDataCons, + tyConKind, tyConTyVars, tyConDataCons, isNewTyCon, + mkSynTyCon, mkAlgTyCon, mkClassTyCon, mkForeignTyCon, + ) +import TysWiredIn ( unitTy ) +import Subst ( substTyWith ) +import DataCon ( dataConOrigArgTys ) +import Var ( varName ) +import FiniteMap import Digraph ( stronglyConnComp, SCC(..) ) -import Name ( Name, NamedThing(..), getSrcLoc, isTvOcc, nameOccName ) +import Name ( Name, getSrcLoc, isTyVarName ) +import NameEnv +import NameSet import Outputable import Maybes ( mapMaybe ) -import UniqSet ( UniqSet, emptyUniqSet, - unitUniqSet, unionUniqSets, - unionManyUniqSets, uniqSetToList ) -import SrcLoc ( SrcLoc ) -import TyCon ( TyCon, Arity ) -import Unique ( Unique, Uniquable(..) ) -import Util ( panic{-, pprTrace-} ) - +import ErrUtils ( Message ) +import HsDecls ( getClassDeclSysNames ) +import Generics ( mkTyConGenInfo ) \end{code} + +%************************************************************************ +%* * +\subsection{Type checking for type and class declarations} +%* * +%************************************************************************ + The main function ~~~~~~~~~~~~~~~~~ \begin{code} -tcTyAndClassDecls1 :: TcEnv s -> InstanceMapper -- Knot tying stuff - -> [RenamedHsDecl] - -> TcM s (TcEnv s) +tcTyAndClassDecls :: RecTcEnv -- Knot tying stuff + -> Module -- Current module + -> [RenamedTyClDecl] + -> TcM [TyThing] -- Returns newly defined things: + -- types, classes and implicit Ids -tcTyAndClassDecls1 unf_env inst_mapper decls +tcTyAndClassDecls unf_env this_mod decls = sortByDependency decls `thenTc` \ groups -> - tcGroups unf_env inst_mapper groups + tcGroups unf_env this_mod groups -tcGroups unf_env inst_mapper [] +tcGroups unf_env this_mod [] = tcGetEnv `thenNF_Tc` \ env -> - returnTc env - -tcGroups unf_env inst_mapper (group:groups) - = tcGroup unf_env inst_mapper group `thenTc` \ (group_tycons, group_classes) -> - - -- Extend the environment using the new tycons and classes - tcExtendTyConEnv [(getName tycon, (kindToTcKind (tyConKind tycon), - if isSynTyCon tycon then Just (tyConArity tycon) else Nothing, - tycon)) - | tycon <- group_tycons] $ + returnTc [] - tcExtendClassEnv [(getName clas, (classKind clas, clas)) - | clas <- group_classes] $ - - - -- Do the remaining groups - tcGroups unf_env inst_mapper groups - where - classKind clas = map (kindToTcKind . tyVarKind) tyvars - where - (tyvars, _, _, _, _) = classBigSig clas +tcGroups unf_env this_mod (group:groups) + = tcGroup unf_env this_mod group `thenTc` \ (env, new_things1) -> + tcSetEnv env $ + tcGroups unf_env this_mod groups `thenTc` \ new_things2 -> + returnTc (new_things1 ++ new_things2) \end{code} Dealing with a group ~~~~~~~~~~~~~~~~~~~~ +Consider a mutually-recursive group, binding +a type constructor T and a class C. -Notice the uses of @zipLazy@, which makes sure -that the knot-tied TyVars, TyCons and Classes aren't looked at too early. +Step 1: getInitialKind + Construct a KindEnv by binding T and C to a kind variable - -\begin{code} -tcGroup :: TcEnv s -> InstanceMapper -> SCC RenamedHsDecl -> TcM s ([TyCon], [Class]) -tcGroup unf_env inst_mapper scc - = -- TIE THE KNOT - fixTc ( \ ~(rec_tycons, rec_classes) -> - - -- EXTEND TYPE AND CLASS ENVIRONMENTS - let - mk_tycon_bind (name, arity) = newKindVar `thenNF_Tc` \ kind -> - returnNF_Tc (name, (kind, arity, find name rec_tycons)) - - mk_class_bind (name, arity) = newKindVars arity `thenNF_Tc` \ kinds -> - returnNF_Tc (name, (kinds, find name rec_classes)) - - find name [] = pprPanic "tcGroup" (ppr name) - find name (thing:things) | name == getName thing = thing - | otherwise = find name things - - in - mapNF_Tc mk_tycon_bind tycon_names_w_arities `thenNF_Tc` \ tycon_binds -> - mapNF_Tc mk_class_bind class_names_w_arities `thenNF_Tc` \ class_binds -> - tcExtendTyConEnv tycon_binds $ - tcExtendClassEnv class_binds $ - - -- DEAL WITH TYPE VARIABLES - tcTyVarScope tyvar_names ( \ tyvars -> - - -- DEAL WITH THE DEFINITIONS THEMSELVES - foldlTc (tcDecl is_rec_group unf_env inst_mapper) ([], []) decls - ) `thenTc` \ (tycons, classes) -> - - returnTc (tycons, classes) - ) - where - is_rec_group = case scc of - AcyclicSCC _ -> NonRecursive - CyclicSCC _ -> Recursive +Step 2: kcTyClDecl + In that environment, do a kind check - decls = case scc of - AcyclicSCC decl -> [decl] - CyclicSCC decls -> decls +Step 3: Zonk the kinds - (tyvar_names, tycon_names_w_arities, class_names_w_arities) = get_binders decls -\end{code} +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 -Dealing with one decl -~~~~~~~~~~~~~~~~~~~~~ -\begin{code} -tcDecl :: RecFlag -- True => recursive group - -> TcEnv s -> InstanceMapper - -> ([TyCon], [Class]) -- Accumulating parameter - -> RenamedHsDecl - -> TcM s ([TyCon], [Class]) - -tcDecl is_rec_group unf_env inst_mapper (tycons, classes) (TyD decl) - = tcTyDecl is_rec_group decl `thenTc` \ tycon -> - returnTc (tycon:tycons, classes) - -tcDecl is_rec_group unf_env inst_mapper (tycons, classes) (ClD decl) - = tcClassDecl1 unf_env inst_mapper decl `thenTc` \ clas -> - returnTc (tycons, clas:classes) -\end{code} +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. + For this step, pass the is-recursive flag as the wimp-out flag + to tcTyClDecl1. + -Dependency analysis -~~~~~~~~~~~~~~~~~~~ -\begin{code} -sortByDependency :: [RenamedHsDecl] -> TcM s [SCC RenamedHsDecl] -sortByDependency decls - = let -- CHECK FOR SYNONYM CYCLES - syn_sccs = stronglyConnComp (filter is_syn_decl edges) - syn_cycles = [ decls | CyclicSCC decls <- syn_sccs] +Step 6: Extend environment + We extend the type environment with bindings not only for the TyCons and Classes, + but also for their "implicit Ids" like data constructors and class selectors - in - checkTc (null syn_cycles) (typeCycleErr syn_cycles) `thenTc_` +Step 7: checkValidTyCl + For a recursive group only, check all the decls again, just + to check all the side conditions on validity. We could not + do this before because we were in a mutually recursive knot. - let -- CHECK FOR CLASS CYCLES - cls_sccs = stronglyConnComp (filter is_cls_decl edges) - cls_cycles = [ decls | CyclicSCC decls <- cls_sccs] - in - checkTc (null cls_cycles) (classCycleErr cls_cycles) `thenTc_` +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. - -- DO THE MAIN DEPENDENCY ANALYSIS +\begin{code} +tcGroup :: RecTcEnv -> Module -> SCC RenamedTyClDecl + -> TcM (TcEnv, -- Input env extended by types and classes only + [TyThing]) -- Things defined by this group + +tcGroup unf_env this_mod scc + = getDOptsTc `thenNF_Tc` \ dflags -> + -- 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 + traceTc (text "starting" <+> ppr final_kinds) `thenTc_` + fixTc ( \ ~(rec_details_list, _, _) -> + -- Step 4 + let + kind_env = mkNameEnv final_kinds + rec_details = mkNameEnv rec_details_list + + tyclss, all_tyclss :: [TyThing] + tyclss = map (buildTyConOrClass dflags 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 = [ATyCon (classTyCon clas) | AClass clas <- tyclss] + ++ tyclss + + -- Calculate variances, and (yes!) feed back into buildTyConOrClass. + rec_vrcs = calcTyConArgVrcs [tc | ATyCon tc <- all_tyclss] + in + -- Step 5 + -- Extend the environment with the final + -- TyCons/Classes and check the decls + tcExtendGlobalEnv all_tyclss $ + mapTc (tcTyClDecl1 unf_env) decls `thenTc` \ tycls_details -> + + -- Return results + tcGetEnv `thenNF_Tc` \ env -> + returnTc (tycls_details, env, all_tyclss) + ) `thenTc` \ (_, env, all_tyclss) -> + + -- Step 7: Check validity + traceTc (text "ready for validity check") `thenTc_` + tcSetEnv env ( + mapTc_ (checkValidTyCl this_mod) decls + ) `thenTc_` + traceTc (text "done") `thenTc_` + let - decl_sccs = stronglyConnComp (filter is_ty_cls_decl edges) + implicit_things = [AnId id | id <- implicitTyThingIds all_tyclss] + new_things = all_tyclss ++ implicit_things in - returnTc decl_sccs + returnTc (env, new_things) where - edges = mapMaybe mk_edges decls - -bag_acyclic (AcyclicSCC scc) = unitBag scc -bag_acyclic (CyclicSCC sccs) = listToBag sccs - -is_syn_decl (TyD (TySynonym _ _ _ _), _, _) = True -is_syn_decl _ = False + is_rec = case scc of + AcyclicSCC _ -> NonRecursive + CyclicSCC _ -> Recursive -is_ty_cls_decl (TyD _, _, _) = True -is_ty_cls_decl (ClD _, _, _) = True -is_ty_cls_decl other = False + decls = case scc of + AcyclicSCC decl -> [decl] + CyclicSCC decls -> decls -is_cls_decl (ClD _, _, _) = True -is_cls_decl other = False +tcTyClDecl1 unf_env decl + | isClassDecl decl = tcAddDeclCtxt decl (tcClassDecl1 decl) + | otherwise = tcAddDeclCtxt decl (tcTyDecl unf_env decl) + +-- We do the validity check over declarations, rather than TyThings +-- only so that we can add a nice context with tcAddDeclCtxt +checkValidTyCl this_mod decl + = tcLookup (tcdName decl) `thenNF_Tc` \ (AGlobal thing) -> + if not (isLocalThing this_mod thing) then + -- Don't bother to check validity for non-local things + returnTc () + else + tcAddDeclCtxt decl $ + case thing of + ATyCon tc -> checkValidTyCon tc + AClass cl -> checkValidClass cl \end{code} -Edges in Type/Class decls -~~~~~~~~~~~~~~~~~~~~~~~~~ + +%************************************************************************ +%* * +\subsection{Step 1: Initial environment} +%* * +%************************************************************************ + \begin{code} -mk_edges decl@(TyD (TyData _ ctxt name _ condecls derivs _ _)) - = Just (decl, uniqueOf name, uniqSetToList (get_ctxt ctxt `unionUniqSets` - get_cons condecls `unionUniqSets` - get_deriv derivs)) +getInitialKind :: RenamedTyClDecl -> NF_TcM (Name, TcKind) +getInitialKind decl + = kcHsTyVars (tyClDeclTyVars decl) `thenNF_Tc` \ arg_kinds -> + newKindVar `thenNF_Tc` \ result_kind -> + returnNF_Tc (tcdName decl, mk_kind arg_kinds result_kind) + +mk_kind tvs_w_kinds res_kind = foldr (mkArrowKind . snd) res_kind tvs_w_kinds +\end{code} -mk_edges decl@(TyD (TySynonym name _ rhs _)) - = Just (decl, uniqueOf name, uniqSetToList (get_ty rhs)) -mk_edges decl@(ClD (ClassDecl ctxt name _ sigs _ _ _ _ _)) - = Just (decl, uniqueOf name, uniqSetToList (get_ctxt ctxt `unionUniqSets` - get_sigs sigs)) +%************************************************************************ +%* * +\subsection{Step 2: Kind checking} +%* * +%************************************************************************ -mk_edges other_decl = Nothing +We need to kind check all types in the mutually recursive group +before we know the kind of the type variables. For example: -get_ctxt ctxt = unionManyUniqSets (map (set_name.fst) ctxt) +class C a where + op :: D b => a -> b -> b + +class D c where + bop :: (Monad c) => ... -get_deriv Nothing = emptyUniqSet -get_deriv (Just clss) = unionManyUniqSets (map set_name clss) +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. -get_cons cons = unionManyUniqSets (map get_con cons) +\begin{code} +kcTyClDecl :: RenamedTyClDecl -> TcM () -get_con (ConDecl _ ctxt details _) - = get_ctxt ctxt `unionUniqSets` get_con_details details +kcTyClDecl decl@(TySynonym {tcdSynRhs = rhs}) + = kcTyClDeclBody decl $ \ result_kind -> + kcHsType rhs `thenTc` \ rhs_kind -> + unifyKind result_kind rhs_kind -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 (NewCon ty) = get_ty ty -get_con_details (RecCon nbtys) = unionManyUniqSets (map (get_bty.snd) nbtys) +kcTyClDecl (ForeignType {}) = returnTc () -get_bty (Banged ty) = get_ty ty -get_bty (Unbanged ty) = get_ty ty +kcTyClDecl decl@(TyData {tcdND = new_or_data, tcdCtxt = context, tcdCons = con_decls}) + = kcTyClDeclBody decl $ \ result_kind -> + kcHsContext context `thenTc_` + mapTc_ kc_con_decl (visibleDataCons con_decls) + where + kc_con_decl (ConDecl _ _ ex_tvs ex_ctxt details loc) + = kcHsTyVars ex_tvs `thenNF_Tc` \ kind_env -> + tcExtendKindEnv kind_env $ + kcConDetails new_or_data ex_ctxt details + +kcTyClDecl decl@(ClassDecl {tcdCtxt = context, tcdSigs = class_sigs}) + = kcTyClDeclBody decl $ \ result_kind -> + kcHsContext context `thenTc_` + mapTc_ kc_sig (filter isClassOpSig class_sigs) + where + kc_sig (ClassOpSig _ _ op_ty loc) = kcHsLiftedSigType op_ty + +kcTyClDeclBody :: RenamedTyClDecl -> (Kind -> TcM a) -> TcM 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 decl thing_inside + = tcAddDeclCtxt decl $ + tcLookup (tcdName decl) `thenNF_Tc` \ thing -> + let + kind = case thing of + AGlobal (ATyCon tc) -> tyConKind tc + AGlobal (AClass cl) -> tyConKind (classTyCon cl) + AThing kind -> kind + -- For some odd reason, a class doesn't include its kind -get_ty (MonoTyVar name) - = if isTvOcc (nameOccName name) then emptyUniqSet else set_name name -get_ty (MonoTyApp ty1 ty2) - = unionUniqSets (get_ty ty1) (get_ty ty2) -get_ty (MonoFunTy ty1 ty2) - = unionUniqSets (get_ty ty1) (get_ty ty2) -get_ty (MonoListTy tc ty) - = set_name tc `unionUniqSets` get_ty ty -get_ty (MonoTupleTy tc tys) - = set_name tc `unionUniqSets` get_tys tys -get_ty (HsForAllTy _ ctxt mty) - = get_ctxt ctxt `unionUniqSets` get_ty mty -get_ty other = panic "TcTyClsDecls:get_ty" + (tyvars_w_kinds, result_kind) = zipFunTys (hsTyVarNames (tyClDeclTyVars decl)) kind + in + tcExtendKindEnv tyvars_w_kinds (thing_inside result_kind) +\end{code} -get_tys tys - = unionManyUniqSets (map get_ty tys) -get_sigs sigs - = unionManyUniqSets (map get_sig sigs) - where - get_sig (ClassOpSig _ _ ty _) = get_ty ty - get_sig other = panic "TcTyClsDecls:get_sig" -set_name name = unitUniqSet (uniqueOf name) +%************************************************************************ +%* * +\subsection{Step 4: Building the tycon/class} +%* * +%************************************************************************ -set_to_bag set = listToBag (uniqSetToList set) +\begin{code} +buildTyConOrClass + :: DynFlags + -> RecFlag -> NameEnv Kind + -> FiniteMap TyCon ArgVrcs -> NameEnv TyThingDetails + -> RenamedTyClDecl -> TyThing + +buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details + (TySynonym {tcdName = tycon_name, tcdTyVars = tyvar_names}) + = 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 dflags is_rec kenv rec_vrcs rec_details + (TyData {tcdND = data_or_new, tcdName = tycon_name, + tcdTyVars = tyvar_names, tcdSysNames = sys_names}) + = ATyCon tycon + where + tycon = mkAlgTyCon tycon_name tycon_kind tyvars ctxt argvrcs + data_cons sel_ids + flavour is_rec gen_info + + gen_info | not (dopt Opt_Generics dflags) = Nothing + | otherwise = mkTyConGenInfo tycon sys_names + + DataTyDetails ctxt data_cons sel_ids = 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 + + -- Watch out! mkTyConApp asks whether the tycon is a NewType, + -- so flavour has to be able to answer this question without consulting rec_details + flavour = case data_or_new of + NewType -> NewTyCon (mkNewTyConRep tycon) + DataType | all_nullary data_cons -> EnumTyCon + | otherwise -> DataTyCon + + all_nullary (DataCons cons) = all (null . dataConOrigArgTys) cons + all_nullary other = False -- Safe choice for unknown data types + -- NB (null . dataConOrigArgTys). It used to say isNullaryDataCon + -- but that looks at the *representation* arity, and that in turn + -- depends on deciding whether to unpack the args, and that + -- depends on whether it's a data type or a newtype --- so + -- in the recursive case we can get a loop. This version is simple! + +buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details + (ForeignType {tcdName = tycon_name, tcdExtName = tycon_ext_name}) + = ATyCon (mkForeignTyCon tycon_name tycon_ext_name liftedTypeKind 0 []) + +buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details + (ClassDecl {tcdName = class_name, tcdTyVars = tyvar_names, + tcdFDs = fundeps, tcdSysNames = name_list} ) + = AClass clas + where + (tycon_name, _, _, _) = getClassDeclSysNames name_list + 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 + is_rec + -- A class can be recursive, and in the case of newtypes + -- this matters. For example + -- class C a where { op :: C b => a -> b -> Int } + -- Because C has only one operation, it is represented by + -- a newtype, and it should be a *recursive* newtype. + -- [If we don't make it a recursive newtype, we'll expand the + -- newtype like a synonym, but that will lead toan inifinite type + + 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 + + flavour = case dataConOrigArgTys dict_con of + -- The tyvars in the datacon are the same as in the class + [rep_ty] -> NewTyCon rep_ty + other -> 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} +\begin{code} +mkNewTyConRep :: TyCon -- The original type constructor + -> Type -- Chosen representation type + -- (guaranteed not to be another newtype) + +-- Find the representation type for this newtype TyCon +-- +-- The non-recursive newtypes are easy, because they look transparent +-- to splitTyConApp_maybe, but recursive ones really are represented as +-- TyConApps (see TypeRep). +-- +-- The trick is to to deal correctly with recursive newtypes +-- such as newtype T = MkT T + +mkNewTyConRep tc + = go [] tc + where + -- Invariant: tc is a NewTyCon + -- tcs have been seen before + go tcs tc + | tc `elem` tcs = unitTy + | otherwise + = let + rep_ty = head (dataConOrigArgTys (head (tyConDataCons tc))) + in + case splitTyConApp_maybe rep_ty of + Nothing -> rep_ty + Just (tc', tys) | not (isNewTyCon tc') -> rep_ty + | otherwise -> go1 (tc:tcs) tc' tys + + go1 tcs tc tys = substTyWith (tyConTyVars tc) tys (go tcs tc) +\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. +%************************************************************************ +%* * +\subsection{Dependency analysis} +%* * +%************************************************************************ -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: +Dependency analysis +~~~~~~~~~~~~~~~~~~~ +\begin{code} +sortByDependency :: [RenamedTyClDecl] -> TcM [SCC RenamedTyClDecl] +sortByDependency decls + = let -- CHECK FOR CLASS CYCLES + cls_sccs = stronglyConnComp (mapMaybe mkClassEdges tycl_decls) + cls_cycles = [ decls | CyclicSCC decls <- cls_sccs] + in + checkTc (null cls_cycles) (classCycleErr cls_cycles) `thenTc_` -class C a where - op :: D b => a -> b -> b + let -- CHECK FOR SYNONYM CYCLES + syn_sccs = stronglyConnComp (filter is_syn_decl edges) + syn_cycles = [ decls | CyclicSCC decls <- syn_sccs] -class D c where - bop :: (Monad c) => ... + in + checkTc (null syn_cycles) (typeCycleErr syn_cycles) `thenTc_` -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. + -- DO THE MAIN DEPENDENCY ANALYSIS + let + decl_sccs = stronglyConnComp edges + in + returnTc decl_sccs + where + tycl_decls = filter (not . isIfaceSigDecl) decls + edges = map mkEdges tycl_decls + + is_syn_decl (d, _, _) = isSynDecl d +\end{code} +Edges in Type/Class decls +~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -get_binders :: [RenamedHsDecl] - -> ([HsTyVar Name], -- TyVars; no dups - [(Name, Maybe Arity)], -- Tycons; no dups; arities for synonyms - [(Name, Arity)]) -- Classes; no dups; with their arities +tyClDeclFTVs :: RenamedTyClDecl -> [Name] + -- Find the free non-tyvar vars +tyClDeclFTVs d = foldNameSet add [] (tyClDeclFVs d) + where + add n fvs | isTyVarName n = fvs + | otherwise = n : fvs -get_binders decls = (bagToList tyvars, bagToList tycons, bagToList classes) - where - (tyvars, tycons, classes) = foldr (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 (TySynonym name tyvars _ _)) - = (listToBag tyvars, unitBag (name, Just (length tyvars)), emptyBag) -get_binders1 (ClD (ClassDecl _ name tyvars sigs _ _ _ _ _)) - = (listToBag tyvars `unionBags` sigs_tvs sigs, - emptyBag, unitBag (name, length tyvars)) - -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 - pty_tvs other = emptyBag +---------------------------------------------------- +-- 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 + +mkClassEdges :: RenamedTyClDecl -> Maybe (RenamedTyClDecl, Name, [Name]) + +mkClassEdges decl@(ClassDecl {tcdCtxt = ctxt, tcdName = name}) = Just (decl, name, [c | HsClassP c _ <- ctxt]) +mkClassEdges other_decl = Nothing + +mkEdges :: RenamedTyClDecl -> (RenamedTyClDecl, Name, [Name]) +mkEdges decl = (decl, tyClDeclName decl, tyClDeclFTVs decl) \end{code} +%************************************************************************ +%* * +\subsection{Error management +%* * +%************************************************************************ + \begin{code} +typeCycleErr, classCycleErr :: [[RenamedTyClDecl]] -> Message + typeCycleErr syn_cycles = vcat (map (pp_cycle "Cycle in type declarations:") syn_cycles) @@ -325,5 +525,6 @@ pp_cycle str decls pp_decl decl = hsep [quotes (ppr name), ptext SLIT("at"), ppr (getSrcLoc name)] where - name = hsDeclName decl + name = tyClDeclName decl + \end{code}