X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcInstDcls.lhs;h=77d65918dde45ce427ca43a8daefd316707189e8;hb=5a1ac8dcffd7477aa448f2f8e1552df8c91381ad;hp=f0c59502afe222a85a9cdcee07353d258ebbade9;hpb=ad7fa9d9112044c6649e2ad5f939485b5425d588;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcInstDcls.lhs b/ghc/compiler/typecheck/TcInstDcls.lhs index f0c5950..77d6591 100644 --- a/ghc/compiler/typecheck/TcInstDcls.lhs +++ b/ghc/compiler/typecheck/TcInstDcls.lhs @@ -13,7 +13,8 @@ import CmdLineOpts ( DynFlag(..) ) import HsSyn ( HsDecl(..), InstDecl(..), TyClDecl(..), HsType(..), MonoBinds(..), HsExpr(..), HsLit(..), Sig(..), HsTyVarBndr(..), - andMonoBindList, collectMonoBinders, isClassDecl, toHsType + andMonoBindList, collectMonoBinders, + isClassDecl, isIfaceInstDecl, toHsType ) import RnHsSyn ( RenamedHsBinds, RenamedInstDecl, RenamedHsDecl, RenamedMonoBinds, RenamedTyClDecl, RenamedHsType, @@ -23,25 +24,25 @@ import TcHsSyn ( TcMonoBinds, mkHsConApp ) import TcBinds ( tcSpecSigs ) import TcClassDcl ( tcMethodBind, badMethodErr ) import TcMonad -import TcMType ( tcInstTyVars, checkValidTheta, checkValidInstHead, instTypeErr, +import TcMType ( tcInstSigTyVars, checkValidTheta, checkValidInstHead, instTypeErr, UserTypeCtxt(..), SourceTyCtxt(..) ) -import TcType ( tcSplitDFunTy, mkClassPred, mkTyVarTy, - tcSplitSigmaTy, tcSplitPredTy_maybe, getClassPredTys +import TcType ( tcSplitDFunTy, mkClassPred, mkTyVarTy, mkTyVarTys, + tcSplitSigmaTy, tcSplitPredTy_maybe, getClassPredTys, + TyVarDetails(..) ) import Inst ( InstOrigin(..), newDicts, instToId, LIE, mkLIE, emptyLIE, plusLIE, plusLIEs ) import TcDeriv ( tcDeriving ) import TcEnv ( TcEnv, tcExtendGlobalValEnv, - tcExtendTyVarEnvForMeths, - tcAddImportedIdInfo, tcLookupClass, + tcExtendTyVarEnvForMeths, tcLookupId, tcLookupClass, InstInfo(..), pprInstInfo, simpleInstInfoTyCon, - simpleInstInfoTy, newDFunName, - isLocalThing, + simpleInstInfoTy, newDFunName ) import InstEnv ( InstEnv, extendInstEnv ) import PprType ( pprClassPred ) -import TcMonoType ( tcHsTyVars, kcHsSigType, tcHsType, tcHsSigType, checkSigTyVars ) +import TcMonoType ( tcHsTyVars, kcHsSigType, tcHsType, tcHsSigType ) +import TcUnify ( checkSigTyVars ) import TcSimplify ( tcSimplifyCheck ) import HscTypes ( HomeSymbolTable, DFunId, ModDetails(..), PackageInstEnv, PersistentRenamerState @@ -49,15 +50,16 @@ import HscTypes ( HomeSymbolTable, DFunId, import Subst ( substTy, substTheta ) import DataCon ( classDataCon ) -import Class ( Class, DefMeth(..), classBigSig ) +import Class ( Class, classBigSig ) import Var ( idName, idType ) import VarSet ( emptyVarSet ) +import Id ( setIdLocalExported ) import MkId ( mkDictFunId ) import FunDeps ( checkInstFDs ) import Generics ( validGenericInstanceType ) import Module ( Module, foldModuleEnv ) import Name ( getSrcLoc ) -import NameSet ( unitNameSet, nameSetToList ) +import NameSet ( unitNameSet, emptyNameSet, nameSetToList ) import PrelInfo ( eRROR_ID ) import TyCon ( TyCon ) import Subst ( mkTopTyVarSubst, substTheta ) @@ -65,6 +67,7 @@ import TysWiredIn ( genericTyCons ) import Name ( Name ) import SrcLoc ( SrcLoc ) import Unique ( Uniquable(..) ) +import Util ( lengthExceeds ) import BasicTypes ( NewOrData(..), Fixity ) import ErrUtils ( dumpIfSet_dyn ) import ListSetOps ( Assoc, emptyAssoc, plusAssoc_C, mapAssoc, @@ -172,9 +175,11 @@ tcInstDecls1 inst_env0 prs hst unf_env get_fixity this_mod decls inst_decls = [inst_decl | InstD inst_decl <- decls] tycl_decls = [decl | TyClD decl <- decls] clas_decls = filter isClassDecl tycl_decls + (imported_inst_ds, local_inst_ds) = partition isIfaceInstDecl inst_decls in -- (1) Do the ordinary instance declarations - mapNF_Tc tcInstDecl1 inst_decls `thenNF_Tc` \ inst_infos -> + mapNF_Tc tcInstDecl1 local_inst_ds `thenNF_Tc` \ local_inst_infos -> + mapNF_Tc tcInstDecl1 imported_inst_ds `thenNF_Tc` \ imported_inst_infos -> -- (2) Instances from generic class declarations getGenericInstances clas_decls `thenTc` \ generic_inst_info -> @@ -187,17 +192,14 @@ tcInstDecls1 inst_env0 prs hst unf_env get_fixity this_mod decls -- e) generic instances inst_env4 -- The result of (b) replaces the cached InstEnv in the PCS let - (local_inst_info, imported_inst_info) - = partition (isLocalThing this_mod . iDFunId) (concat inst_infos) - - imported_dfuns = map (tcAddImportedIdInfo unf_env . iDFunId) - imported_inst_info - hst_dfuns = foldModuleEnv ((++) . md_insts) [] hst + local_inst_info = concat local_inst_infos + imported_inst_info = concat imported_inst_infos + hst_dfuns = foldModuleEnv ((++) . md_insts) [] hst in -- pprTrace "tcInstDecls" (vcat [ppr imported_dfuns, ppr hst_dfuns]) $ - addInstDFuns inst_env0 imported_dfuns `thenNF_Tc` \ inst_env1 -> + addInstInfos inst_env0 imported_inst_info `thenNF_Tc` \ inst_env1 -> addInstDFuns inst_env1 hst_dfuns `thenNF_Tc` \ inst_env2 -> addInstInfos inst_env2 local_inst_info `thenNF_Tc` \ inst_env3 -> addInstInfos inst_env3 generic_inst_info `thenNF_Tc` \ inst_env4 -> @@ -206,7 +208,7 @@ tcInstDecls1 inst_env0 prs hst unf_env get_fixity this_mod decls -- note that we only do derivings for things in this module; -- we ignore deriving decls from interfaces! -- This stuff computes a context for the derived instance decl, so it - -- needs to know about all the instances possible; hecne inst_env4 + -- needs to know about all the instances possible; hence inst_env4 tcDeriving prs this_mod inst_env4 get_fixity tycl_decls `thenTc` \ (deriv_inst_info, deriv_binds) -> addInstInfos inst_env4 deriv_inst_info `thenNF_Tc` \ final_inst_env -> @@ -262,14 +264,15 @@ tcInstDecl1 decl@(InstDecl poly_ty binds uprags maybe_dfun_name src_loc) checkValidInstHead tau `thenTc_` checkTc (checkInstFDs theta clas inst_tys) (instTypeErr (pprClassPred clas inst_tys) msg) `thenTc_` - newDFunName clas inst_tys src_loc + newDFunName clas inst_tys src_loc `thenTc` \ dfun_name -> + returnTc (mkDictFunId dfun_name clas tyvars inst_tys theta) Just dfun_name -> -- An interface-file instance declaration - returnNF_Tc dfun_name - ) `thenNF_Tc` \ dfun_name -> - let - dfun_id = mkDictFunId dfun_name clas tyvars inst_tys theta - in + -- Should be in scope by now, because we should + -- have sucked in its interface-file definition + -- So it will be replete with its unfolding etc + tcLookupId dfun_name + ) `thenNF_Tc` \ dfun_id -> returnTc [InstInfo { iDFunId = dfun_id, iBinds = binds, iPrags = uprags }] where msg = parens (ptext SLIT("the instance types do not agree with the functional dependencies of the class")) @@ -329,7 +332,7 @@ get_generics decl@(ClassDecl {tcdName = class_name, tcdMeths = Just def_methods, | null groups = returnTc [] -- The comon case: no generic default methods - | otherwise -- A local class decl with generic default methods + | otherwise -- A source class decl with generic default methods = recoverNF_Tc (returnNF_Tc []) $ tcAddDeclCtxt decl $ tcLookupClass class_name `thenTc` \ clas -> @@ -347,7 +350,7 @@ get_generics decl@(ClassDecl {tcdName = class_name, tcdMeths = Just def_methods, tc_inst_infos = [(simpleInstInfoTyCon i, i) | i <- inst_infos] bad_groups = [group | group <- equivClassesByUniq get_uniq tc_inst_infos, - length group > 1] + group `lengthExceeds` 1] get_uniq (tc,_) = getUnique tc in mapTc (addErrTc . dupGenericInsts) bad_groups `thenTc_` @@ -522,15 +525,15 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id, let (inst_tyvars, dfun_theta, clas, inst_tys) = tcSplitDFunTy (idType dfun_id) in - tcInstTyVars inst_tyvars `thenNF_Tc` \ (inst_tyvars', _, tenv) -> + tcInstSigTyVars InstTv inst_tyvars `thenNF_Tc` \ inst_tyvars' -> let + tenv = mkTopTyVarSubst inst_tyvars (mkTyVarTys inst_tyvars') inst_tys' = map (substTy tenv) inst_tys dfun_theta' = substTheta tenv dfun_theta origin = InstanceDeclOrigin (class_tyvars, sc_theta, _, op_items) = classBigSig clas - dm_ids = [dm_id | (_, DefMeth dm_id) <- op_items] sel_names = [idName sel_id | (sel_id, _) <- op_items] -- Instantiate the super-class context with inst_tys @@ -551,14 +554,15 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id, -- The type variable from the dict fun actually scope -- over the bindings. They were gotten from -- the original instance declaration - tcExtendGlobalValEnv dm_ids ( - -- Default-method Ids may be mentioned in synthesised RHSs + + -- Default-method Ids may be mentioned in synthesised RHSs, + -- but they'll already be in the environment. mapAndUnzip3Tc (tcMethodBind clas origin inst_tyvars' inst_tys' dfun_theta' monobinds uprags True) op_items - )) `thenTc` \ (method_binds_s, insts_needed_s, meth_insts) -> + ) `thenTc` \ (method_binds_s, insts_needed_s, meth_insts) -> -- Deal with SPECIALISE instance pragmas by making them -- look like SPECIALISE pragmas for the dfun @@ -603,14 +607,22 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id, -- Create the result bindings let + local_dfun_id = setIdLocalExported dfun_id + -- Reason for setIdLocalExported: see notes with MkId.mkDictFunId + dict_constr = classDataCon clas scs_and_meths = map instToId (sc_dicts ++ meth_insts) this_dict_id = instToId this_dict - inlines = unitNameSet (idName dfun_id) + inlines | null dfun_arg_dicts = emptyNameSet + | otherwise = unitNameSet (idName dfun_id) -- Always inline the dfun; this is an experimental decision -- because it makes a big performance difference sometimes. -- Often it means we can do the method selection, and then -- inline the method as well. Marcin's idea; see comments below. + -- + -- BUT: don't inline it if it's a constant dictionary; + -- we'll get all the benefit without inlining, and we get + -- a **lot** of code duplication if we inline it dict_rhs | null scs_and_meths @@ -642,7 +654,7 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id, = AbsBinds zonked_inst_tyvars (map instToId dfun_arg_dicts) - [(inst_tyvars', dfun_id, this_dict_id)] + [(inst_tyvars', local_dfun_id, this_dict_id)] inlines (lie_binds1 `AndMonoBinds` lie_binds2 `AndMonoBinds`