X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcTyClsDecls.lhs;h=fcf1636b09d7bcc3cf4cb65606d8bf5f4ec4e109;hb=d069cec2bd92d4156aeab80f7eb1f222a82e4103;hp=532729fb51ed4e1cbdbb031b8a10a38ce3b39f7a;hpb=90fa6b84fdc99ba99c0b7df9691ca69d50b62530;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcTyClsDecls.lhs b/ghc/compiler/typecheck/TcTyClsDecls.lhs index 532729f..fcf1636 100644 --- a/ghc/compiler/typecheck/TcTyClsDecls.lhs +++ b/ghc/compiler/typecheck/TcTyClsDecls.lhs @@ -10,45 +10,47 @@ module TcTyClsDecls ( #include "HsVersions.h" -import HsSyn ( HsDecl(..), TyClDecl(..), - HsTyVarBndr, - ConDecl(..), - Sig(..), HsPred(..), - tyClDeclName, hsTyVarNames, +import CmdLineOpts ( DynFlags, DynFlag(..), dopt ) +import HsSyn ( TyClDecl(..), + ConDecl(..), Sig(..), HsPred(..), + tyClDeclName, hsTyVarNames, tyClDeclTyVars, isIfaceSigDecl, isClassDecl, isSynDecl, isClassOpSig ) -import RnHsSyn ( RenamedHsDecl, RenamedTyClDecl, tyClDeclFVs ) -import BasicTypes ( RecFlag(..), NewOrData(..) ) +import RnHsSyn ( RenamedTyClDecl, tyClDeclFVs ) +import BasicTypes ( RecFlag(..), NewOrData(..), isRec ) +import HscTypes ( implicitTyThingIds ) import TcMonad -import TcEnv ( TcEnv, TyThing(..), TyThingDetails(..), - tcExtendKindEnv, tcLookupGlobal, tcExtendGlobalEnv ) -import TcTyDecls ( tcTyDecl1, kcConDetails, mkNewTyConRep ) +import TcEnv ( TcEnv, RecTcEnv, TcTyThing(..), TyThing(..), TyThingDetails(..), + tcExtendKindEnv, tcLookup, tcExtendGlobalEnv, tcExtendGlobalValEnv ) +import TcTyDecls ( tcTyDecl1, kcConDetails ) import TcClassDcl ( tcClassDecl1 ) -import TcMonoType ( kcHsTyVars, kcHsType, kcHsBoxedSigType, kcHsContext, mkTyClTyVars ) -import TcType ( TcKind, newKindVar, zonkKindEnv ) - -import TcUnify ( unifyKind ) import TcInstDcls ( tcAddDeclCtxt ) -import Type ( Kind, mkArrowKind, boxedTypeKind, zipFunTys ) +import TcMonoType ( kcHsTyVars, kcHsType, kcHsLiftedSigType, kcHsContext, mkTyClTyVars ) +import TcMType ( unifyKind, newKindVar, zonkKindEnv ) +import TcType ( tcSplitTyConApp_maybe, + Type, Kind, mkArrowKind, liftedTypeKind, zipFunTys + ) +import Subst ( mkTyVarSubst, substTy ) import Variance ( calcTyConArgVrcs ) import Class ( Class, mkClass, classTyCon ) -import TyCon ( TyCon, tyConKind, ArgVrcs, AlgTyConFlavour(..), - mkSynTyCon, mkAlgTyConRep, mkClassTyCon ) -import DataCon ( isNullaryDataCon ) -import Var ( varName ) +import TyCon ( TyCon, ArgVrcs, AlgTyConFlavour(..), + tyConName, tyConKind, tyConTyVars, tyConArity, tyConDataCons, + mkSynTyCon, mkAlgTyCon, mkClassTyCon, mkForeignTyCon, isNewTyCon, + isRecursiveTyCon ) +import TysWiredIn ( unitTy ) +import DataCon ( isNullaryDataCon, dataConOrigArgTys ) +import Var ( varName, varType ) import FiniteMap import Digraph ( stronglyConnComp, SCC(..) ) -import Name ( Name, NamedThing(..), NameEnv, getSrcLoc, - mkNameEnv, lookupNameEnv_NF, isTyVarName - ) +import Name ( Name, getSrcLoc, isTyVarName ) +import NameEnv import NameSet import Outputable import Maybes ( mapMaybe ) import ErrUtils ( Message ) import HsDecls ( getClassDeclSysNames ) import Generics ( mkTyConGenInfo ) -import CmdLineOpts ( DynFlags ) \end{code} @@ -61,8 +63,8 @@ import CmdLineOpts ( DynFlags ) The main function ~~~~~~~~~~~~~~~~~ \begin{code} -tcTyAndClassDecls :: TcEnv -- Knot tying stuff - -> [RenamedHsDecl] +tcTyAndClassDecls :: RecTcEnv -- Knot tying stuff + -> [RenamedTyClDecl] -> TcM TcEnv tcTyAndClassDecls unf_env decls @@ -75,7 +77,7 @@ tcGroups unf_env [] tcGroups unf_env (group:groups) = tcGroup unf_env group `thenTc` \ env -> - tcSetEnv env $ + tcSetEnv env $ tcGroups unf_env groups \end{code} @@ -104,14 +106,26 @@ Step 4: buildTyConOrClass 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. + 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. + +Step 6: tcTyClDecl1 again + For a recursive group only, check all the decls again, just + but this time with the wimp flag off. Now we can check things + like whether a function argument is an unlifted tuple, looking + through type synonyms properly. We can't do that in Step 5. + +Step 7: 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 + 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. \begin{code} -tcGroup :: TcEnv -> SCC RenamedTyClDecl -> TcM TcEnv +tcGroup :: RecTcEnv -> SCC RenamedTyClDecl -> TcM TcEnv tcGroup unf_env scc = getDOptsTc `thenTc` \ dflags -> -- Step 1 @@ -124,33 +138,55 @@ tcGroup unf_env scc zonkKindEnv initial_kinds `thenNF_Tc` \ final_kinds -> -- Tie the knot - fixTc ( \ ~(rec_details_list, _) -> + 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 :: [(Name, TyThing)] + 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 = [ (getName tycon, ATyCon tycon) | (_, AClass clas) <- tyclss, - let tycon = classTyCon clas - ] ++ tyclss + 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] + rec_vrcs = calcTyConArgVrcs [tc | ATyCon tc <- all_tyclss] in -- Step 5 - tcExtendGlobalEnv all_tyclss $ - mapTc (tcTyClDecl1 unf_env) decls `thenTc` \ tycls_details -> - tcGetEnv `thenNF_Tc` \ env -> - returnTc (tycls_details, env) - ) `thenTc` \ (_, env) -> - returnTc env + tcExtendGlobalEnv all_tyclss $ + mapTc (tcTyClDecl1 is_rec unf_env) decls `thenTc` \ tycls_details -> + + -- Return results + tcGetEnv `thenNF_Tc` \ env -> + returnTc (tycls_details, all_tyclss, env) + ) `thenTc` \ (_, all_tyclss, env) -> + + tcSetEnv env $ + + traceTc (text "ready for pass 2" <+> ppr (isRec is_rec)) `thenTc_` + + -- Step 6 + -- For a recursive group, check all the types again, + -- this time with the wimp flag off + (if isRec is_rec then + mapTc_ (tcTyClDecl1 NonRecursive unf_env) decls + else + returnTc () + ) `thenTc_` + + traceTc (text "done") `thenTc_` + + -- Step 7 + -- Extend the environment with the final TyCons/Classes + -- and their implicit Ids + tcExtendGlobalValEnv (implicitTyThingIds all_tyclss) tcGetEnv + where is_rec = case scc of AcyclicSCC _ -> NonRecursive @@ -160,12 +196,9 @@ tcGroup unf_env scc AcyclicSCC decl -> [decl] CyclicSCC decls -> decls -tcTyClDecl1 unf_env decl - = tcAddDeclCtxt decl $ - if isClassDecl decl then - tcClassDecl1 unf_env decl - else - tcTyDecl1 decl +tcTyClDecl1 is_rec unf_env decl + | isClassDecl decl = tcAddDeclCtxt decl (tcClassDecl1 is_rec unf_env decl) + | otherwise = tcAddDeclCtxt decl (tcTyDecl1 is_rec unf_env decl) \end{code} @@ -177,18 +210,10 @@ tcTyClDecl1 unf_env decl \begin{code} getInitialKind :: RenamedTyClDecl -> NF_TcM (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) - -getInitialKind (TyData _ _ name tyvars _ _ _ _ _ _) - = kcHsTyVars tyvars `thenNF_Tc` \ arg_kinds -> - returnNF_Tc (name, mk_kind arg_kinds boxedTypeKind) - -getInitialKind (ClassDecl _ name tyvars _ _ _ _ _ ) - = kcHsTyVars tyvars `thenNF_Tc` \ arg_kinds -> - returnNF_Tc (name, mk_kind arg_kinds boxedTypeKind) +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} @@ -216,49 +241,45 @@ Monad c in bop's type signature means that D must have kind Type->Type. \begin{code} kcTyClDecl :: RenamedTyClDecl -> TcM () -kcTyClDecl decl@(TySynonym tycon_name hs_tyvars rhs loc) - = tcAddDeclCtxt decl $ - kcTyClDeclBody tycon_name hs_tyvars $ \ result_kind -> - kcHsType rhs `thenTc` \ rhs_kind -> +kcTyClDecl decl@(TySynonym {tcdSynRhs = rhs}) + = kcTyClDeclBody decl $ \ 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 -> +kcTyClDecl (ForeignType {}) = returnTc () + +kcTyClDecl decl@(TyData {tcdND = new_or_data, tcdCtxt = context, tcdCons = con_decls}) + = kcTyClDeclBody decl $ \ 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 -> + = 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_` + 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) = tcAddSrcLoc loc (kcHsBoxedSigType op_ty) + kc_sig (ClassOpSig _ _ op_ty loc) = kcHsLiftedSigType op_ty -kcTyClDeclBody :: Name -> [HsTyVarBndr Name] -- Kind of the tycon/cls and its tyvars - -> (Kind -> TcM a) -- Thing inside - -> TcM a +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 tc_name hs_tyvars thing_inside - = tcLookupGlobal tc_name `thenNF_Tc` \ thing -> +kcTyClDeclBody decl thing_inside + = tcAddDeclCtxt decl $ + tcLookup (tcdName decl) `thenNF_Tc` \ thing -> let kind = case thing of - ATyCon tc -> tyConKind tc - AClass cl -> tyConKind (classTyCon cl) + 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 - (tyvars_w_kinds, result_kind) = zipFunTys (hsTyVarNames hs_tyvars) kind + (tyvars_w_kinds, result_kind) = zipFunTys (hsTyVarNames (tyClDeclTyVars decl)) kind in tcExtendKindEnv tyvars_w_kinds (thing_inside result_kind) \end{code} @@ -275,13 +296,11 @@ buildTyConOrClass :: DynFlags -> 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 + -> RenamedTyClDecl -> TyThing buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details - (TySynonym tycon_name tyvar_names rhs src_loc) - = (tycon_name, ATyCon tycon) + (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 @@ -291,31 +310,43 @@ buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details argvrcs = lookupWithDefaultFM rec_vrcs bogusVrcs tycon buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details - (TyData data_or_new context tycon_name tyvar_names _ nconstrs _ src_loc name1 name2) - = (tycon_name, ATyCon tycon) + (TyData {tcdND = data_or_new, tcdName = tycon_name, tcdTyVars = tyvar_names, + tcdNCons = nconstrs, tcdSysNames = sys_names}) + = ATyCon tycon where - tycon = mkAlgTyConRep tycon_name tycon_kind tyvars ctxt argvrcs - data_cons nconstrs - derived_classes + tycon = mkAlgTyCon tycon_name tycon_kind tyvars ctxt argvrcs + data_cons nconstrs sel_ids flavour is_rec gen_info - gen_info = mkTyConGenInfo dflags tycon name1 name2 - DataTyDetails ctxt data_cons derived_classes = lookupNameEnv_NF rec_details tycon_name + 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 isNullaryDataCon data_cons -> EnumTyCon - | otherwise -> DataTyCon + NewType -> NewTyCon (mkNewTyConRep tycon) + DataType | all (null . dataConOrigArgTys) data_cons -> EnumTyCon + | otherwise -> DataTyCon + -- 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 - (ClassDecl context class_name - tyvar_names fundeps class_sigs def_methods - name_list src_loc) - = (class_name, AClass clas) + (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 @@ -326,16 +357,25 @@ buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details 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 - n_fields = length sc_sel_ids + length op_items - flavour | n_fields == 1 = NewTyCon (mkNewTyConRep tycon) - | otherwise = DataTyCon + 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 @@ -348,6 +388,19 @@ buildTyConOrClass dflags is_rec kenv rec_vrcs rec_details bogusVrcs = panic "Bogus tycon arg variances" \end{code} +\begin{code} +mkNewTyConRep :: TyCon -- The original type constructor + -> Type -- Chosen representation type +-- Find the representation type for this newtype TyCon +-- For a recursive type constructor we give an error thunk, +-- because we never look at the rep in that case +-- (see notes on newypes in types/TypeRep + +mkNewTyConRep tc + | isRecursiveTyCon tc = pprPanic "Attempt to get the rep of newtype" (ppr tc) + | otherwise = head (dataConOrigArgTys (head (tyConDataCons tc))) +\end{code} + %************************************************************************ %* * @@ -358,7 +411,7 @@ bogusVrcs = panic "Bogus tycon arg variances" Dependency analysis ~~~~~~~~~~~~~~~~~~~ \begin{code} -sortByDependency :: [RenamedHsDecl] -> TcM [SCC RenamedTyClDecl] +sortByDependency :: [RenamedTyClDecl] -> TcM [SCC RenamedTyClDecl] sortByDependency decls = let -- CHECK FOR CLASS CYCLES cls_sccs = stronglyConnComp (mapMaybe mkClassEdges tycl_decls) @@ -379,7 +432,7 @@ sortByDependency decls in returnTc decl_sccs where - tycl_decls = [d | TyClD d <- decls, not (isIfaceSigDecl d)] + tycl_decls = filter (not . isIfaceSigDecl) decls edges = map mkEdges tycl_decls is_syn_decl (d, _, _) = isSynDecl d @@ -390,6 +443,7 @@ Edges in Type/Class decls \begin{code} tyClDeclFTVs :: RenamedTyClDecl -> [Name] + -- Find the free non-tyvar vars tyClDeclFTVs d = foldNameSet add [] (tyClDeclFVs d) where add n fvs | isTyVarName n = fvs @@ -402,10 +456,9 @@ tyClDeclFTVs d = foldNameSet add [] (tyClDeclFVs d) mkClassEdges :: RenamedTyClDecl -> Maybe (RenamedTyClDecl, Name, [Name]) -mkClassEdges decl@(ClassDecl ctxt name _ _ _ _ _ _) = Just (decl, name, [c | HsPClass c _ <- ctxt]) -mkClassEdges other_decl = Nothing +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}