X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcInstDcls.lhs;h=2e74b6ae887ce877e1af0bb9b6ac770bad64f38b;hp=c7fc8ab56ff9f896303d4819c6462cc0c1ef7281;hb=7fc01c4671980ea3c66d549c0ece4d82fd3f5ade;hpb=3bc73cd67e6cfacd2fc823019f1b6012cdf1ccb4 diff --git a/compiler/typecheck/TcInstDcls.lhs b/compiler/typecheck/TcInstDcls.lhs index c7fc8ab..2e74b6a 100644 --- a/compiler/typecheck/TcInstDcls.lhs +++ b/compiler/typecheck/TcInstDcls.lhs @@ -19,21 +19,23 @@ import Inst import InstEnv import FamInst import FamInstEnv +import MkCore ( nO_METHOD_BINDING_ERROR_ID ) import TcDeriv import TcEnv -import RnEnv ( lookupGlobalOccRn ) import RnSource ( addTcgDUs ) +import TcSimplify( simplifySuperClass ) import TcHsType import TcUnify -import TcSimplify import Type import Coercion import TyCon import DataCon import Class import Var +import VarSet ( emptyVarSet ) +import CoreUtils ( mkPiTypes ) import CoreUnfold ( mkDFunUnfolding ) -import PrelNames ( inlineIdName ) +import CoreSyn ( Expr(Var) ) import Id import MkId import Name @@ -46,7 +48,7 @@ import Bag import BasicTypes import HscTypes import FastString - +import Maybes ( orElse ) import Data.Maybe import Control.Monad import Data.List @@ -179,8 +181,8 @@ Instead we use a cunning trick. Note [Single-method classes] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -If the class has just one method (or, more accurately, just one elemen -of {superclasses + methods}), then we want a different strategy. +If the class has just one method (or, more accurately, just one element +of {superclasses + methods}), then we still use the *same* strategy class C a where op :: a -> a instance C a => C [a] where op = @@ -193,18 +195,47 @@ a top-level axiom: op :: forall a. C a -> (a -> a) op a d = d |> (Co:C a) + MkC :: forall a. (a->a) -> C a + MkC = /\a.\op. op |> (sym Co:C a) + df :: forall a. C a => C [a] - {-# INLINE df #-} - df = $cop_list |> (forall a. C a -> (sym (Co:C a)) + {-# NOINLINE df DFun[ $cop_list ] #-} + df = /\a. \d. MkC ($cop_list a d) - $cop_list :: forall a. C a => a -> a + $cop_list :: forall a. C a => [a] -> [a] $cop_list = -So the ClassOp is just a cast; and so is the dictionary function. -(The latter doesn't even have any lambdas.) We can inline both freely. -No need for fancy BuiltIn rules. Indeed the BuiltinRule stuff does -not work well for newtypes because it uses exprIsConApp_maybe. +The "constructor" MkC expands to a cast, as does the class-op selector. +The RULE works just like for multi-field dictionaries: + + * (df a d) returns (Just (MkC,..,[$cop_list a d])) + to exprIsConApp_Maybe + + * The RULE for op picks the right result + +This is a bit of a hack, because (df a d) isn't *really* a constructor +application. But it works just fine in this case, exprIsConApp_maybe +is otherwise used only when we hit a case expression which will have +a real data constructor in it. + +The biggest reason for doing it this way, apart from uniformity, is +that we want to be very careful when we have + instance C a => C [a] where + {-# INLINE op #-} + op = ... +then we'll get an INLINE pragma on $cop_list but it's important that +$cop_list only inlines when it's applied to *two* arguments (the +dictionary and the list argument +The danger is that we'll get something like + op_list :: C a => [a] -> [a] + op_list = /\a.\d. $cop_list a d +and then we'll eta expand, and then we'll inline TOO EARLY. This happened in +Trac #3772 and I spent far too long fiddling around trying to fix it. +Look at the test for Trac #3772. + + (Note: re-reading the above, I can't see how using the + uniform story solves the problem.) Note [Subtle interaction of recursion and overlap] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -213,7 +244,7 @@ Consider this instance C a => C [a] where op1 x = op2 x ++ op2 x op2 x = ... - intance C [Int] where + instance C [Int] where ... When type-checking the C [a] instance, we need a C [a] dictionary (for @@ -294,16 +325,16 @@ tcInstDecls1 tycl_decls inst_decls deriv_decls -- round) -- (1) Do class and family instance declarations - ; let { idxty_decls = filter (isFamInstDecl . unLoc) tycl_decls } + ; idx_tycons <- mapAndRecoverM (tcFamInstDecl TopLevel) $ + filter (isFamInstDecl . unLoc) tycl_decls ; local_info_tycons <- mapAndRecoverM tcLocalInstDecl1 inst_decls - ; idx_tycons <- mapAndRecoverM tcIdxTyInstDeclTL idxty_decls ; let { (local_info, at_tycons_s) = unzip local_info_tycons ; at_idx_tycons = concat at_tycons_s ++ idx_tycons ; clas_decls = filter (isClassDecl.unLoc) tycl_decls ; implicit_things = concatMap implicitTyThings at_idx_tycons - ; aux_binds = mkAuxBinds at_idx_tycons + ; aux_binds = mkRecSelBinds at_idx_tycons } -- (2) Add the tycons of indexed types and their implicit @@ -315,9 +346,9 @@ tcInstDecls1 tycl_decls inst_decls deriv_decls -- Next, construct the instance environment so far, consisting -- of - -- a) local instance decls - -- b) generic instances - -- c) local family instance decls + -- (a) local instance decls + -- (b) generic instances + -- (c) local family instance decls ; addInsts local_info $ addInsts generic_inst_info $ addFamInsts at_idx_tycons $ do { @@ -337,27 +368,6 @@ tcInstDecls1 tycl_decls inst_decls deriv_decls generic_inst_info ++ deriv_inst_info ++ local_info, aux_binds `plusHsValBinds` deriv_binds) }}} - where - -- Make sure that toplevel type instance are not for associated types. - -- !!!TODO: Need to perform this check for the TyThing of type functions, - -- too. - tcIdxTyInstDeclTL ldecl@(L loc decl) = - do { tything <- tcFamInstDecl ldecl - ; setSrcSpan loc $ - when (isAssocFamily tything) $ - addErr $ assocInClassErr (tcdName decl) - ; return tything - } - isAssocFamily (ATyCon tycon) = - case tyConFamInst_maybe tycon of - Nothing -> panic "isAssocFamily: no family?!?" - Just (fam, _) -> isTyConAssoc fam - isAssocFamily _ = panic "isAssocFamily: no tycon?!?" - -assocInClassErr :: Name -> SDoc -assocInClassErr name = - ptext (sLit "Associated type") <+> quotes (ppr name) <+> - ptext (sLit "must be inside a class instance") addInsts :: [InstInfo Name] -> TcM a -> TcM a addInsts infos thing_inside @@ -390,12 +400,12 @@ tcLocalInstDecl1 (L loc (InstDecl poly_ty binds uprags ats)) ; (tyvars, theta, tau) <- tcHsInstHead poly_ty -- Now, check the validity of the instance. - ; (clas, inst_tys) <- checkValidInstHead tau - ; checkValidInstance tyvars theta clas inst_tys + ; (clas, inst_tys) <- checkValidInstance poly_ty tyvars theta tau -- Next, process any associated types. ; idx_tycons <- recoverM (return []) $ - do { idx_tycons <- checkNoErrs $ mapAndRecoverM tcFamInstDecl ats + do { idx_tycons <- checkNoErrs $ + mapAndRecoverM (tcFamInstDecl NotTopLevel) ats ; checkValidAndMissingATs clas (tyvars, inst_tys) (zip ats idx_tycons) ; return idx_tycons } @@ -454,10 +464,6 @@ tcLocalInstDecl1 (L loc (InstDecl poly_ty binds uprags ats)) case find ((atName ==) . tyConName) (classATs clas) of Nothing -> addErrTc $ badATErr clas atName -- not in this class Just atycon -> - case assocTyConArgPoss_maybe atycon of - Nothing -> panic "checkIndexes': AT has no args poss?!?" - Just poss -> - -- The following is tricky! We need to deal with three -- complications: (1) The AT possibly only uses a subset of -- the class parameters as indexes and those it uses may be in @@ -485,7 +491,19 @@ tcLocalInstDecl1 (L loc (InstDecl poly_ty binds uprags ats)) -- instance types with the instance type variable sharing its -- source lexeme. -- - let relevantInstTys = map (instTys !!) poss + let poss :: [Int] + -- For *associated* type families, gives the position + -- of that 'TyVar' in the class argument list (0-indexed) + -- e.g. class C a b c where { type F c a :: *->* } + -- Then we get Just [2,0] + poss = catMaybes [ tv `elemIndex` classTyVars clas + | tv <- tyConTyVars atycon] + -- We will get Nothings for the "extra" type + -- variables in an associated data type + -- e.g. class C a where { data D a :: *->* } + -- here D gets arity 2 and has two tyvars + + relevantInstTys = map (instTys !!) poss instArgs = map Just relevantInstTys ++ repeat Nothing -- extra arguments renaming = substSameTyVar atTvs instTvs @@ -522,7 +540,7 @@ tcLocalInstDecl1 (L loc (InstDecl poly_ty binds uprags ats)) \begin{code} tcInstDecls2 :: [LTyClDecl Name] -> [InstInfo Name] - -> TcM (LHsBinds Id, TcLclEnv) + -> TcM (LHsBinds Id) -- (a) From each class declaration, -- generate any default-method bindings -- (b) From each instance decl @@ -531,18 +549,18 @@ tcInstDecls2 :: [LTyClDecl Name] -> [InstInfo Name] tcInstDecls2 tycl_decls inst_decls = do { -- (a) Default methods from class decls let class_decls = filter (isClassDecl . unLoc) tycl_decls - ; (dm_ids_s, dm_binds_s) <- mapAndUnzipM tcClassDecl2 class_decls + ; dm_binds_s <- mapM tcClassDecl2 class_decls + ; let dm_binds = unionManyBags dm_binds_s - ; tcExtendIdEnv (concat dm_ids_s) $ do - -- (b) instance declarations - { inst_binds_s <- mapM tcInstDecl2 inst_decls + ; let dm_ids = collectHsBindsBinders dm_binds + -- Add the default method Ids (again) + -- See Note [Default methods and instances] + ; inst_binds_s <- tcExtendIdEnv dm_ids $ + mapM tcInstDecl2 inst_decls -- Done - ; let binds = unionManyBags dm_binds_s `unionBags` - unionManyBags inst_binds_s - ; tcl_env <- getLclEnv -- Default method Ids in here - ; return (binds, tcl_env) } } + ; return (dm_binds `unionBags` unionManyBags inst_binds_s) } tcInstDecl2 :: InstInfo Name -> TcM (LHsBinds Id) tcInstDecl2 (InstInfo { iSpec = ispec, iBinds = ibinds }) @@ -555,140 +573,26 @@ tcInstDecl2 (InstInfo { iSpec = ispec, iBinds = ibinds }) loc = getSrcSpan dfun_id \end{code} +See Note [Default methods and instances] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +The default method Ids are already in the type environment (see Note +[Default method Ids and Template Haskell] in TcTyClsDcls), BUT they +don't have their InlinePragmas yet. Usually that would not matter, +because the simplifier propagates information from binding site to +use. But, unusually, when compiling instance decls we *copy* the +INLINE pragma from the default method to the method for that +particular operation (see Note [INLINE and default methods] below). + +So right here in tcInstDecl2 we must re-extend the type envt with +the default method Ids replete with their INLINE pragmas. Urk. \begin{code} tc_inst_decl2 :: Id -> InstBindings Name -> TcM (LHsBinds Id) -- Returns a binding for the dfun - ------------------------- --- Derived newtype instances; surprisingly tricky! --- --- class Show a => Foo a b where ... --- newtype N a = MkN (Tree [a]) deriving( Foo Int ) --- --- The newtype gives an FC axiom looking like --- axiom CoN a :: N a ~ Tree [a] --- (see Note [Newtype coercions] in TyCon for this unusual form of axiom) --- --- So all need is to generate a binding looking like: --- dfunFooT :: forall a. (Foo Int (Tree [a], Show (N a)) => Foo Int (N a) --- dfunFooT = /\a. \(ds:Show (N a)) (df:Foo (Tree [a])). --- case df `cast` (Foo Int (sym (CoN a))) of --- Foo _ op1 .. opn -> Foo ds op1 .. opn --- --- If there are no superclasses, matters are simpler, because we don't need the case --- see Note [Newtype deriving superclasses] in TcDeriv.lhs - -tc_inst_decl2 dfun_id (NewTypeDerived coi) - = do { let rigid_info = InstSkol - origin = SigOrigin rigid_info - inst_ty = idType dfun_id - inst_tvs = fst (tcSplitForAllTys inst_ty) - ; (inst_tvs', theta, inst_head_ty) <- tcSkolSigType rigid_info inst_ty - -- inst_head_ty is a PredType - - ; let (cls, cls_inst_tys) = tcSplitDFunHead inst_head_ty - (class_tyvars, sc_theta, _, _) = classBigSig cls - cls_tycon = classTyCon cls - sc_theta' = substTheta (zipOpenTvSubst class_tyvars cls_inst_tys) sc_theta - Just (initial_cls_inst_tys, last_ty) = snocView cls_inst_tys - - (rep_ty, wrapper) - = case coi of - IdCo -> (last_ty, idHsWrapper) - ACo co -> (snd (coercionKind co'), WpCast (mk_full_coercion co')) - where - co' = substTyWith inst_tvs (mkTyVarTys inst_tvs') co - -- NB: the free variable of coi are bound by the - -- universally quantified variables of the dfun_id - -- This is weird, and maybe we should make NewTypeDerived - -- carry a type-variable list too; but it works fine - - ----------------------- - -- mk_full_coercion - -- The inst_head looks like (C s1 .. sm (T a1 .. ak)) - -- But we want the coercion (C s1 .. sm (sym (CoT a1 .. ak))) - -- with kind (C s1 .. sm (T a1 .. ak) ~ C s1 .. sm ) - -- where rep_ty is the (eta-reduced) type rep of T - -- So we just replace T with CoT, and insert a 'sym' - -- NB: we know that k will be >= arity of CoT, because the latter fully eta-reduced - - mk_full_coercion co = mkTyConApp cls_tycon - (initial_cls_inst_tys ++ [mkSymCoercion co]) - -- Full coercion : (Foo Int (Tree [a]) ~ Foo Int (N a) - - rep_pred = mkClassPred cls (initial_cls_inst_tys ++ [rep_ty]) - -- In our example, rep_pred is (Foo Int (Tree [a])) - - ; sc_loc <- getInstLoc InstScOrigin - ; sc_dicts <- newDictBndrs sc_loc sc_theta' - ; inst_loc <- getInstLoc origin - ; dfun_dicts <- newDictBndrs inst_loc theta - ; rep_dict <- newDictBndr inst_loc rep_pred - ; this_dict <- newDictBndr inst_loc (mkClassPred cls cls_inst_tys) - - -- Figure out bindings for the superclass context from dfun_dicts - -- Don't include this_dict in the 'givens', else - -- sc_dicts get bound by just selecting from this_dict!! - ; sc_binds <- addErrCtxt superClassCtxt $ - tcSimplifySuperClasses inst_loc this_dict dfun_dicts - (rep_dict:sc_dicts) - - -- It's possible that the superclass stuff might unified something - -- in the envt with one of the clas_tyvars - ; checkSigTyVars inst_tvs' - - ; let coerced_rep_dict = wrapId wrapper (instToId rep_dict) - - ; body <- make_body cls_tycon cls_inst_tys sc_dicts coerced_rep_dict - ; let dict_bind = mkVarBind (instToId this_dict) (noLoc body) - - ; return (unitBag $ noLoc $ - AbsBinds inst_tvs' (map instToVar dfun_dicts) - [(inst_tvs', dfun_id, instToId this_dict, [])] - (dict_bind `consBag` sc_binds)) } - where - ----------------------- - -- (make_body C tys scs coreced_rep_dict) - -- returns - -- (case coerced_rep_dict of { C _ ops -> C scs ops }) - -- But if there are no superclasses, it returns just coerced_rep_dict - -- See Note [Newtype deriving superclasses] in TcDeriv.lhs - - make_body cls_tycon cls_inst_tys sc_dicts coerced_rep_dict - | null sc_dicts -- Case (a) - = return coerced_rep_dict - | otherwise -- Case (b) - = do { op_ids <- newSysLocalIds (fsLit "op") op_tys - ; dummy_sc_dict_ids <- newSysLocalIds (fsLit "sc") (map idType sc_dict_ids) - ; let the_pat = ConPatOut { pat_con = noLoc cls_data_con, pat_tvs = [], - pat_dicts = dummy_sc_dict_ids, - pat_binds = emptyLHsBinds, - pat_args = PrefixCon (map nlVarPat op_ids), - pat_ty = pat_ty} - the_match = mkSimpleMatch [noLoc the_pat] the_rhs - the_rhs = mkHsConApp cls_data_con cls_inst_tys $ - map HsVar (sc_dict_ids ++ op_ids) - - -- Warning: this HsCase scrutinises a value with a PredTy, which is - -- never otherwise seen in Haskell source code. It'd be - -- nicer to generate Core directly! - ; return (HsCase (noLoc coerced_rep_dict) $ - MatchGroup [the_match] (mkFunTy pat_ty pat_ty)) } - where - sc_dict_ids = map instToId sc_dicts - pat_ty = mkTyConApp cls_tycon cls_inst_tys - cls_data_con = head (tyConDataCons cls_tycon) - cls_arg_tys = dataConInstArgTys cls_data_con cls_inst_tys - op_tys = dropList sc_dict_ids cls_arg_tys - ------------------------- --- Ordinary instances - -tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) - = do { let rigid_info = InstSkol - inst_ty = idType dfun_id - loc = getSrcSpan dfun_id +tc_inst_decl2 dfun_id inst_binds + = do { let rigid_info = InstSkol + inst_ty = idType dfun_id + loc = getSrcSpan dfun_id -- Instantiate the instance decl with skolem constants ; (inst_tyvars', dfun_theta', inst_head') <- tcSkolSigType rigid_info inst_ty @@ -701,62 +605,49 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) -- Instantiate the super-class context with inst_tys sc_theta' = substTheta (zipOpenTvSubst class_tyvars inst_tys') sc_theta - origin = SigOrigin rigid_info -- Create dictionary Ids from the specified instance contexts. - ; inst_loc <- getInstLoc origin - ; dfun_dicts <- newDictBndrs inst_loc dfun_theta' -- Includes equalities - ; this_dict <- newDictBndr inst_loc (mkClassPred clas inst_tys') + ; dfun_ev_vars <- newEvVars dfun_theta' + ; self_dict <- newSelfDict clas inst_tys' -- Default-method Ids may be mentioned in synthesised RHSs, -- but they'll already be in the environment. - - -- Cook up a binding for "this = df d1 .. dn", + -- Cook up a binding for "self = df d1 .. dn", -- to use in each method binding - -- Need to clone the dict in case it is floated out, and - -- then clashes with its friends - ; cloned_this <- cloneDict this_dict - ; let cloned_this_bind = mkVarBind (instToId cloned_this) $ - L loc $ wrapId app_wrapper dfun_id - app_wrapper = mkWpApps dfun_lam_vars <.> mkWpTyApps (mkTyVarTys inst_tyvars') - dfun_lam_vars = map instToVar dfun_dicts -- Includes equalities - nested_this_pair - | null inst_tyvars' && null dfun_theta' = (this_dict, emptyBag) - | otherwise = (cloned_this, unitBag cloned_this_bind) + -- Why? See Note [Subtle interaction of recursion and overlap] + ; let self_ev_bind = EvBind self_dict $ + EvDFunApp dfun_id (mkTyVarTys inst_tyvars') dfun_ev_vars -- Deal with 'SPECIALISE instance' pragmas -- See Note [SPECIALISE instance pragmas] - ; let spec_inst_sigs = filter isSpecInstLSig uprags - -- The filter removes the pragmas for methods - ; spec_inst_prags <- mapM (wrapLocM (tcSpecInst dfun_id)) spec_inst_sigs + ; spec_info <- tcSpecInstPrags dfun_id inst_binds -- Typecheck the methods - ; let prag_fn = mkPragFun uprags - tc_meth = tcInstanceMethod loc standalone_deriv - clas inst_tyvars' - dfun_dicts inst_tys' - nested_this_pair - prag_fn spec_inst_prags monobinds - - ; (meth_ids, meth_binds) <- tcExtendTyVarEnv inst_tyvars' $ - mapAndUnzipM tc_meth op_items + ; (meth_ids, meth_binds) + <- tcExtendTyVarEnv inst_tyvars' $ + tcInstanceMethods dfun_id clas inst_tyvars' dfun_ev_vars + inst_tys' self_ev_bind spec_info + op_items inst_binds -- Figure out bindings for the superclass context - ; sc_loc <- getInstLoc InstScOrigin - ; sc_dicts <- newDictOccs sc_loc sc_theta' -- These are wanted - ; let tc_sc = tcSuperClass inst_loc inst_tyvars' dfun_dicts nested_this_pair - ; (sc_ids, sc_binds) <- mapAndUnzipM tc_sc (sc_sels `zip` sc_dicts) + ; let tc_sc = tcSuperClass inst_tyvars' dfun_ev_vars self_ev_bind + (sc_eqs, sc_dicts) = splitAt (classSCNEqs clas) sc_theta' + ; (sc_dict_ids, sc_binds) <- ASSERT( equalLength sc_sels sc_dicts ) + ASSERT( all isEqPred sc_eqs ) + mapAndUnzipM tc_sc (sc_sels `zip` sc_dicts) - -- It's possible that the superclass stuff might unified - -- something in the envt with one of the inst_tyvars' - ; checkSigTyVars inst_tyvars' + -- NOT FINISHED! + ; (_eq_sc_binds, sc_eq_vars) <- checkConstraints InstSkol emptyVarSet + inst_tyvars' dfun_ev_vars $ + emitWanteds ScOrigin sc_eqs -- Create the result bindings - ; let dict_constr = classDataCon clas - this_dict_id = instToId this_dict - dict_bind = mkVarBind this_dict_id dict_rhs - dict_rhs = foldl mk_app inst_constr (sc_ids ++ meth_ids) - inst_constr = L loc $ wrapId (mkWpTyApps inst_tys') + ; let dict_constr = classDataCon clas + dict_bind = mkVarBind self_dict dict_rhs + dict_rhs = foldl mk_app inst_constr dict_and_meth_ids + dict_and_meth_ids = sc_dict_ids ++ meth_ids + inst_constr = L loc $ wrapId (mkWpEvVarApps sc_eq_vars + <.> mkWpTyApps inst_tys') (dataConWrapId dict_constr) -- We don't produce a binding for the dict_constr; instead we -- rely on the simplifier to unfold this saturated application @@ -767,67 +658,83 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) mk_app :: LHsExpr Id -> Id -> LHsExpr Id mk_app fun arg_id = L loc (HsApp fun (L loc (wrapId arg_wrapper arg_id))) - arg_wrapper = mkWpApps dfun_lam_vars <.> mkWpTyApps (mkTyVarTys inst_tyvars') - - dfun_id_w_fun | isNewTyCon (classTyCon clas) - = dfun_id -- Just let the dfun inline; see Note [Single-method classes] - | otherwise - = dfun_id -- Do not inline; instead give it a magic DFunFunfolding - -- See Note [ClassOp/DFun selection] - `setIdUnfolding` mkDFunUnfolding dict_constr (sc_ids ++ meth_ids) + arg_wrapper = mkWpEvVarApps dfun_ev_vars <.> mkWpTyApps (mkTyVarTys inst_tyvars') + + -- Do not inline the dfun; instead give it a magic DFunFunfolding + -- See Note [ClassOp/DFun selection] + -- See also note [Single-method classes] + dfun_id_w_fun = dfun_id + `setIdUnfolding` mkDFunUnfolding inst_ty (map Var dict_and_meth_ids) + -- Not right for equality superclasses `setInlinePragma` dfunInlinePragma - main_bind = noLoc $ AbsBinds - inst_tyvars' - dfun_lam_vars - [(inst_tyvars', dfun_id_w_fun, this_dict_id, spec_inst_prags)] - (unitBag dict_bind) + (spec_inst_prags, _) = spec_info + main_bind = AbsBinds { abs_tvs = inst_tyvars' + , abs_ev_vars = dfun_ev_vars + , abs_exports = [(inst_tyvars', dfun_id_w_fun, self_dict, + SpecPrags spec_inst_prags)] + , abs_ev_binds = emptyTcEvBinds + , abs_binds = unitBag dict_bind } - ; showLIE (text "instance") - ; return (unitBag main_bind `unionBags` - listToBag meth_binds `unionBags` - listToBag sc_binds) } + ; return (unitBag (L loc main_bind) `unionBags` + listToBag meth_binds `unionBags` + listToBag sc_binds) + } +------------------------------ +tcSpecInstPrags :: DFunId -> InstBindings Name + -> TcM ([Located TcSpecPrag], PragFun) +tcSpecInstPrags _ (NewTypeDerived {}) + = return ([], \_ -> []) +tcSpecInstPrags dfun_id (VanillaInst binds uprags _) + = do { spec_inst_prags <- mapM (wrapLocM (tcSpecInst dfun_id)) $ + filter isSpecInstLSig uprags + -- The filter removes the pragmas for methods + ; return (spec_inst_prags, mkPragFun uprags binds) } ------------------------------ -tcSuperClass :: InstLoc -> [TyVar] -> [Inst] - -> (Inst, LHsBinds Id) - -> (Id, Inst) -> TcM (Id, LHsBind Id) +tcSuperClass :: [TyVar] -> [EvVar] + -> EvBind + -> (Id, PredType) -> TcM (Id, LHsBind Id) -- Build a top level decl like -- sc_op = /\a \d. let this = ... in -- let sc = ... in -- sc -- The "this" part is just-in-case (discarded if not used) -- See Note [Recursive superclasses] -tcSuperClass inst_loc tyvars dicts (this_dict, this_bind) - (sc_sel, sc_dict) - = addErrCtxt superClassCtxt $ - do { sc_binds <- tcSimplifySuperClasses inst_loc - this_dict dicts [sc_dict] - -- Don't include this_dict in the 'givens', else - -- sc_dicts get bound by just selecting from this_dict!! +tcSuperClass tyvars dicts + self_ev_bind@(EvBind self_dict _) + (sc_sel, sc_pred) + = do { (ev_binds, wanted, sc_dict) + <- newImplication InstSkol emptyVarSet tyvars dicts $ + emitWanted ScOrigin sc_pred + + ; simplifySuperClass self_dict wanted + -- We include self_dict in the 'givens'; the simplifier + -- is clever enough to stop sc_pred geting bound by just + -- selecting from self_dict!! ; uniq <- newUnique - ; let sc_op_ty = mkSigmaTy tyvars (map dictPred dicts) - (mkPredTy (dictPred sc_dict)) + ; let sc_op_ty = mkForAllTys tyvars $ mkPiTypes dicts (varType sc_dict) sc_op_name = mkDerivedInternalName mkClassOpAuxOcc uniq (getName sc_sel) sc_op_id = mkLocalId sc_op_name sc_op_ty - sc_id = instToVar sc_dict - sc_op_bind = AbsBinds tyvars - (map instToVar dicts) - [(tyvars, sc_op_id, sc_id, [])] - (this_bind `unionBags` sc_binds) + sc_op_bind = VarBind { var_id = sc_op_id, var_inline = False + , var_rhs = L noSrcSpan $ wrapId sc_wrapper sc_dict } + sc_wrapper = mkWpTyLams tyvars + <.> mkWpLams dicts + <.> mkWpLet (EvBinds (unitBag self_ev_bind)) + <.> mkWpLet ev_binds ; return (sc_op_id, noLoc sc_op_bind) } \end{code} Note [Recursive superclasses] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -See Trac #1470 for why we would *like* to add "this_dict" to the +See Trac #1470 for why we would *like* to add "self_dict" to the available instances here. But we can't do so because then the superclases -get satisfied by selection from this_dict, and that leads to an immediate -loop. What we need is to add this_dict to Avails without adding its +get satisfied by selection from self_dict, and that leads to an immediate +loop. What we need is to add self_dict to Avails without adding its superclasses, and we currently have no way to do that. Note [SPECIALISE instance pragmas] @@ -873,13 +780,14 @@ SpecPrag which, as it turns out, can be used unchanged for each method. The "it turns out" bit is delicate, but it works fine! \begin{code} -tcSpecInst :: Id -> Sig Name -> TcM SpecPrag +tcSpecInst :: Id -> Sig Name -> TcM TcSpecPrag tcSpecInst dfun_id prag@(SpecInstSig hs_ty) = addErrCtxt (spec_ctxt prag) $ do { let name = idName dfun_id ; (tyvars, theta, tau) <- tcHsInstHead hs_ty ; let spec_ty = mkSigmaTy tyvars theta tau - ; co_fn <- tcSubExp (SpecPragOrigin name) (idType dfun_id) spec_ty + ; co_fn <- tcSubType (SpecPragOrigin name) (SigSkol SpecInstCtxt) + (idType dfun_id) spec_ty ; return (SpecPrag co_fn defaultInlinePragma) } where spec_ctxt prag = hang (ptext (sLit "In the SPECIALISE pragma")) 2 (ppr prag) @@ -902,104 +810,105 @@ tcInstanceMethod - Use tcValBinds to do the checking \begin{code} -tcInstanceMethod :: SrcSpan -> Bool -> Class -> [TcTyVar] -> [Inst] - -> [TcType] - -> (Inst, LHsBinds Id) -- "This" and its binding - -> TcPragFun -- Local prags - -> [LSpecPrag] -- Arising from 'SPECLALISE instance' - -> LHsBinds Name - -> (Id, DefMeth) - -> TcM (Id, LHsBind Id) +tcInstanceMethods :: DFunId -> Class -> [TcTyVar] + -> [EvVar] + -> [TcType] + -> EvBind -- "This" and its binding + -> ([Located TcSpecPrag], PragFun) + -> [(Id, DefMeth)] + -> InstBindings Name + -> TcM ([Id], [LHsBind Id]) -- The returned inst_meth_ids all have types starting -- forall tvs. theta => ... - -tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys - (this_dict, this_dict_bind) - prag_fn spec_inst_prags binds_in (sel_id, dm_info) - = do { uniq <- newUnique - ; let meth_name = mkDerivedInternalName mkClassOpAuxOcc uniq sel_name - ; local_meth_name <- newLocalName sel_name - -- Base the local_meth_name on the selector name, becuase - -- type errors from tcInstanceMethodBody come from here - - ; let local_meth_ty = instantiateMethod clas sel_id inst_tys - meth_ty = mkSigmaTy tyvars (map dictPred dfun_dicts) local_meth_ty - meth_id = mkLocalId meth_name meth_ty - local_meth_id = mkLocalId local_meth_name local_meth_ty - - -------------- - tc_body rn_bind - = add_meth_ctxt rn_bind $ - do { (meth_id1, spec_prags) <- tcPrags NonRecursive False True - meth_id (prag_fn sel_name) - ; tcInstanceMethodBody (instLoc this_dict) - tyvars dfun_dicts - ([this_dict], this_dict_bind) - meth_id1 local_meth_id - meth_sig_fn - (spec_inst_prags ++ spec_prags) - rn_bind } - - -------------- - tc_default :: DefMeth -> TcM (Id, LHsBind Id) - -- The user didn't supply a method binding, so we have to make - -- up a default binding, in a way depending on the default-method info - - tc_default NoDefMeth -- No default method at all - = do { warnMissingMethod sel_id - ; return (meth_id, mkVarBind meth_id $ - mkLHsWrap lam_wrapper error_rhs) } - - tc_default GenDefMeth -- Derivable type classes stuff - = do { meth_bind <- mkGenericDefMethBind clas inst_tys sel_id local_meth_name - ; tc_body meth_bind } - - tc_default DefMeth -- An polymorphic default method - = do { -- Build the typechecked version directly, - -- without calling typecheck_method; - -- see Note [Default methods in instances] - -- Generate /\as.\ds. let this = df as ds - -- in $dm inst_tys this - -- The 'let' is necessary only because HsSyn doesn't allow - -- you to apply a function to a dictionary *expression*. - dm_name <- lookupGlobalOccRn (mkDefMethRdrName sel_name) - -- Might not be imported, but will be an OrigName - ; dm_id <- tcLookupId dm_name - ; inline_id <- tcLookupId inlineIdName - ; let dm_inline_prag = idInlinePragma dm_id - dm_app = HsWrap (WpApp (instToId this_dict) <.> mkWpTyApps inst_tys) $ - HsVar dm_id - rhs | isInlinePragma dm_inline_prag -- See Note [INLINE and default methods] - = HsApp (L loc (HsWrap (WpTyApp local_meth_ty) (HsVar inline_id))) - (L loc dm_app) - | otherwise = dm_app - - meth_bind = L loc $ VarBind { var_id = local_meth_id - , var_rhs = L loc rhs - , var_inline = False } - meth_id1 = meth_id `setInlinePragma` dm_inline_prag - -- Copy the inline pragma (if any) from the default - -- method to this version. Note [INLINE and default methods] - - bind = AbsBinds { abs_tvs = tyvars, abs_dicts = dfun_lam_vars - , abs_exports = [( tyvars, meth_id1 - , local_meth_id, spec_inst_prags)] - , abs_binds = this_dict_bind `unionBags` unitBag meth_bind } - -- Default methods in an instance declaration can't have their own - -- INLINE or SPECIALISE pragmas. It'd be possible to allow them, but - -- currently they are rejected with - -- "INLINE pragma lacks an accompanying binding" - - ; return (meth_id1, L loc bind) } - - ; case findMethodBind sel_name local_meth_name binds_in of - Just user_bind -> tc_body user_bind -- User-supplied method binding - Nothing -> tc_default dm_info -- None supplied - } +tcInstanceMethods dfun_id clas tyvars dfun_ev_vars inst_tys + self_dict_ev (spec_inst_prags, prag_fn) + op_items (VanillaInst binds _ standalone_deriv) + = mapAndUnzipM tc_item op_items where - sel_name = idName sel_id - - meth_sig_fn _ = Just [] -- The 'Just' says "yes, there's a type sig" + ---------------------- + tc_item :: (Id, DefMeth) -> TcM (Id, LHsBind Id) + tc_item (sel_id, dm_info) + = case findMethodBind (idName sel_id) binds of + Just user_bind -> tc_body sel_id standalone_deriv user_bind + Nothing -> tc_default sel_id dm_info + + ---------------------- + tc_body :: Id -> Bool -> LHsBind Name -> TcM (TcId, LHsBind Id) + tc_body sel_id generated_code rn_bind + = add_meth_ctxt generated_code rn_bind $ + do { (meth_id, local_meth_id) <- mkMethIds clas tyvars dfun_ev_vars + inst_tys sel_id + ; (meth_id1, spec_prags) <- tcPrags NonRecursive False True + meth_id (prag_fn (idName sel_id)) + + ; bind <- tcInstanceMethodBody InstSkol + tyvars dfun_ev_vars + mb_dict_ev + meth_id1 local_meth_id + meth_sig_fn + (SpecPrags (spec_inst_prags ++ spec_prags)) + rn_bind + ; return (meth_id1, bind) } + + ---------------------- + tc_default :: Id -> DefMeth -> TcM (TcId, LHsBind Id) + tc_default sel_id GenDefMeth -- Derivable type classes stuff + = do { meth_bind <- mkGenericDefMethBind clas inst_tys sel_id + ; tc_body sel_id False {- Not generated code? -} meth_bind } + + tc_default sel_id NoDefMeth -- No default method at all + = do { warnMissingMethod sel_id + ; (meth_id, _) <- mkMethIds clas tyvars dfun_ev_vars + inst_tys sel_id + ; return (meth_id, mkVarBind meth_id $ + mkLHsWrap lam_wrapper error_rhs) } + where + error_rhs = L loc $ HsApp error_fun error_msg + error_fun = L loc $ wrapId (WpTyApp meth_tau) nO_METHOD_BINDING_ERROR_ID + error_msg = L loc (HsLit (HsStringPrim (mkFastString error_string))) + meth_tau = funResultTy (applyTys (idType sel_id) inst_tys) + error_string = showSDoc (hcat [ppr loc, text "|", ppr sel_id ]) + lam_wrapper = mkWpTyLams tyvars <.> mkWpLams dfun_ev_vars + + tc_default sel_id (DefMeth dm_name) -- A polymorphic default method + = do { -- Build the typechecked version directly, + -- without calling typecheck_method; + -- see Note [Default methods in instances] + -- Generate /\as.\ds. let this = df as ds + -- in $dm inst_tys this + -- The 'let' is necessary only because HsSyn doesn't allow + -- you to apply a function to a dictionary *expression*. + + ; (meth_id, local_meth_id) <- mkMethIds clas tyvars dfun_ev_vars + inst_tys sel_id + ; dm_id <- tcLookupId dm_name + ; let dm_inline_prag = idInlinePragma dm_id + EvBind self_dict _ = self_dict_ev + rhs = HsWrap (mkWpEvVarApps [self_dict] <.> mkWpTyApps inst_tys) $ + HsVar dm_id + + meth_bind = L loc $ VarBind { var_id = local_meth_id + , var_rhs = L loc rhs + , var_inline = False } + meth_id1 = meth_id `setInlinePragma` dm_inline_prag + -- Copy the inline pragma (if any) from the default + -- method to this version. Note [INLINE and default methods] + + bind = AbsBinds { abs_tvs = tyvars, abs_ev_vars = dfun_ev_vars + , abs_exports = [( tyvars, meth_id1, local_meth_id + , SpecPrags spec_inst_prags)] + , abs_ev_binds = EvBinds (unitBag self_dict_ev) + , abs_binds = unitBag meth_bind } + -- Default methods in an instance declaration can't have their own + -- INLINE or SPECIALISE pragmas. It'd be possible to allow them, but + -- currently they are rejected with + -- "INLINE pragma lacks an accompanying binding" + + ; return (meth_id1, L loc bind) } + + ---------------------- + loc = getSrcSpan dfun_id + meth_sig_fn _ = Just ([],loc) -- The 'Just' says "yes, there's a type sig" -- But there are no scoped type variables from local_method_id -- Only the ones from the instance decl itself, which are already -- in scope. Example: @@ -1007,22 +916,114 @@ tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys -- instance C [c] where { op = } -- In , 'c' is scope but 'b' is not! - error_rhs = L loc $ HsApp error_fun error_msg - error_fun = L loc $ wrapId (WpTyApp meth_tau) nO_METHOD_BINDING_ERROR_ID - error_msg = L loc (HsLit (HsStringPrim (mkFastString error_string))) - meth_tau = funResultTy (applyTys (idType sel_id) inst_tys) - error_string = showSDoc (hcat [ppr loc, text "|", ppr sel_id ]) - - dfun_lam_vars = map instToVar dfun_dicts - lam_wrapper = mkWpTyLams tyvars <.> mkWpLams dfun_lam_vars + mb_dict_ev = if null tyvars then Nothing else Just self_dict_ev + -- Only need the self_dict stuff if there are type + -- variables involved; otherwise overlap is not possible + -- See Note [Subtle interaction of recursion and overlap] + -- in TcInstDcls -- For instance decls that come from standalone deriving clauses -- we want to print out the full source code if there's an error -- because otherwise the user won't see the code at all - add_meth_ctxt rn_bind thing - | standalone_deriv = addLandmarkErrCtxt (derivBindCtxt clas inst_tys rn_bind) thing - | otherwise = thing + add_meth_ctxt generated_code rn_bind thing + | generated_code = addLandmarkErrCtxt (derivBindCtxt clas inst_tys rn_bind) thing + | otherwise = thing + + +tcInstanceMethods dfun_id clas tyvars dfun_ev_vars inst_tys + _ _ op_items (NewTypeDerived coi _) + +-- Running example: +-- class Show b => Foo a b where +-- op :: a -> b -> b +-- newtype N a = MkN (Tree [a]) +-- deriving instance (Show p, Foo Int p) => Foo Int (N p) +-- -- NB: standalone deriving clause means +-- -- that the contex is user-specified +-- Hence op :: forall a b. Foo a b => a -> b -> b +-- +-- We're going to make an instance like +-- instance (Show p, Foo Int p) => Foo Int (N p) +-- op = $copT +-- +-- $copT :: forall p. (Show p, Foo Int p) => Int -> N p -> N p +-- $copT p (d1:Show p) (d2:Foo Int p) +-- = op Int (Tree [p]) rep_d |> op_co +-- where +-- rep_d :: Foo Int (Tree [p]) = ...d1...d2... +-- op_co :: (Int -> Tree [p] -> Tree [p]) ~ (Int -> T p -> T p) +-- We get op_co by substituting [Int/a] and [co/b] in type for op +-- where co : [p] ~ T p +-- +-- Notice that the dictionary bindings "..d1..d2.." must be generated +-- by the constraint solver, since the may be +-- user-specified. + + = do { rep_d_stuff <- checkConstraints InstSkol emptyVarSet tyvars dfun_ev_vars $ + emitWanted ScOrigin rep_pred + + ; mapAndUnzipM (tc_item rep_d_stuff) op_items } + where + loc = getSrcSpan dfun_id + + inst_tvs = fst (tcSplitForAllTys (idType dfun_id)) + Just (init_inst_tys, _) = snocView inst_tys + rep_ty = fst (coercionKind co) -- [p] + rep_pred = mkClassPred clas (init_inst_tys ++ [rep_ty]) + + -- co : [p] ~ T p + co = substTyWith inst_tvs (mkTyVarTys tyvars) $ + case coi of { IdCo ty -> ty ; + ACo co -> mkSymCoercion co } + + ---------------- + tc_item :: (TcEvBinds, EvVar) -> (Id, DefMeth) -> TcM (TcId, LHsBind TcId) + tc_item (rep_ev_binds, rep_d) (sel_id, _) + = do { (meth_id, local_meth_id) <- mkMethIds clas tyvars dfun_ev_vars + inst_tys sel_id + + ; let meth_rhs = wrapId (mk_op_wrapper sel_id rep_d) sel_id + meth_bind = VarBind { var_id = local_meth_id + , var_rhs = L loc meth_rhs + , var_inline = False } + + bind = AbsBinds { abs_tvs = tyvars, abs_ev_vars = dfun_ev_vars + , abs_exports = [(tyvars, meth_id, + local_meth_id, noSpecPrags)] + , abs_ev_binds = rep_ev_binds + , abs_binds = unitBag $ L loc meth_bind } + + ; return (meth_id, L loc bind) } + + ---------------- + mk_op_wrapper :: Id -> EvVar -> HsWrapper + mk_op_wrapper sel_id rep_d + = WpCast (substTyWith sel_tvs (init_inst_tys ++ [co]) local_meth_ty) + <.> WpEvApp (EvId rep_d) + <.> mkWpTyApps (init_inst_tys ++ [rep_ty]) + where + (sel_tvs, sel_rho) = tcSplitForAllTys (idType sel_id) + (_, local_meth_ty) = tcSplitPredFunTy_maybe sel_rho + `orElse` pprPanic "tcInstanceMethods" (ppr sel_id) + +---------------------- +mkMethIds :: Class -> [TcTyVar] -> [EvVar] -> [TcType] -> Id -> TcM (TcId, TcId) +mkMethIds clas tyvars dfun_ev_vars inst_tys sel_id + = do { uniq <- newUnique + ; let meth_name = mkDerivedInternalName mkClassOpAuxOcc uniq sel_name + ; local_meth_name <- newLocalName sel_name + -- Base the local_meth_name on the selector name, becuase + -- type errors from tcInstanceMethodBody come from here + + ; let meth_id = mkLocalId meth_name meth_ty + local_meth_id = mkLocalId local_meth_name local_meth_ty + ; return (meth_id, local_meth_id) } + where + local_meth_ty = instantiateMethod clas sel_id inst_tys + meth_ty = mkForAllTys tyvars $ mkPiTypes dfun_ev_vars local_meth_ty + sel_name = idName sel_id +---------------------- wrapId :: HsWrapper -> id -> HsExpr id wrapId wrapper id = mkHsWrap wrapper (HsVar id) @@ -1068,7 +1069,8 @@ From the class decl we get $dmfoo :: forall v x. Baz v x => x -> x $dmfoo y = -Notice that the type is ambiguous. That's fine, though. The instance decl generates +Notice that the type is ambiguous. That's fine, though. The instance +decl generates $dBazIntInt = MkBaz fooIntInt fooIntInt = $dmfoo Int Int $dBazIntInt @@ -1080,8 +1082,9 @@ less work to generate the translated version! Note [INLINE and default methods] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -We *copy* any INLINE pragma from the default method to the instance. -Example: +Default methods need special case. They are supposed to behave rather like +macros. For exmample + class Foo a where op1, op2 :: Bool -> a -> a @@ -1089,31 +1092,57 @@ Example: op1 b x = op2 (not b) x instance Foo Int where + -- op1 via default method + op2 b x = + +The instance declaration should behave + + just as if 'op1' had been defined with the + code, and INLINE pragma, from its original + definition. + +That is, just as if you'd written + + instance Foo Int where op2 b x = -Then we generate: + {-# INLINE op1 #-} + op1 b x = op2 (not b) x + +So for the above example we generate: + {-# INLINE $dmop1 #-} + -- $dmop1 has an InlineCompulsory unfolding $dmop1 d b x = op2 d (not b) x $fFooInt = MkD $cop1 $cop2 {-# INLINE $cop1 #-} - $cop1 = inline $dmop1 $fFooInt + $cop1 = $dmop1 $fFooInt $cop2 = -Note carefully: - a) We copy $dmop1's inline pragma to $cop1. Otherwise - we'll just inline the former in the latter and stop, which - isn't what the user expected +Note carefullly: + +* We *copy* any INLINE pragma from the default method $dmop1 to the + instance $cop1. Otherwise we'll just inline the former in the + latter and stop, which isn't what the user expected - b) We use the magic 'inline' Id to ensure that $dmop1 really is - inlined in $cop1, even though the latter itself has an INLINE pragma - That is important to allow the mutual recursion between $fooInt and - $cop1 to be broken +* Regardless of its pragma, we give the default method an + unfolding with an InlineCompulsory source. That means + that it'll be inlined at every use site, notably in + each instance declaration, such as $cop1. This inlining + must happen even though + a) $dmop1 is not saturated in $cop1 + b) $cop1 itself has an INLINE pragma -This is all regrettably delicate. + It's vital that $dmop1 *is* inlined in this way, to allow the mutual + recursion between $fooInt and $cop1 to be broken + +* To communicate the need for an InlineCompulsory to the desugarer + (which makes the Unfoldings), we use the IsDefaultMethod constructor + in TcSpecPrags. %************************************************************************ @@ -1138,9 +1167,6 @@ instDeclCtxt2 dfun_ty inst_decl_ctxt :: SDoc -> SDoc inst_decl_ctxt doc = ptext (sLit "In the instance declaration for") <+> quotes doc -superClassCtxt :: SDoc -superClassCtxt = ptext (sLit "When checking the super-classes of an instance declaration") - atInstCtxt :: Name -> SDoc atInstCtxt name = ptext (sLit "In the associated type instance for") <+> quotes (ppr name)