X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcInstDcls.lhs;h=d7aafc1f11736bbebd7ba500aedcd84538254277;hb=1a9245caefb80a3c4c5965aaacdf9a607e792e1c;hp=a2fb4ceba5270722d827ffd6341c055a8b615cb3;hpb=6f2fc241ccad5e32826ecad404d0b8166b93de5b;p=ghc-hetmet.git diff --git a/compiler/typecheck/TcInstDcls.lhs b/compiler/typecheck/TcInstDcls.lhs index a2fb4ce..d7aafc1 100644 --- a/compiler/typecheck/TcInstDcls.lhs +++ b/compiler/typecheck/TcInstDcls.lhs @@ -21,7 +21,6 @@ import FamInst import FamInstEnv import TcDeriv import TcEnv -import RnEnv ( lookupGlobalOccRn ) import RnSource ( addTcgDUs ) import TcHsType import TcUnify @@ -33,7 +32,7 @@ import DataCon import Class import Var import CoreUnfold ( mkDFunUnfolding ) -import PrelNames ( inlineIdName ) +import CoreSyn ( Expr(Var) ) import Id import MkId import Name @@ -179,8 +178,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,21 +192,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 INLINE on df is vital, else $cop_list occurs just once and is inlined, -which is a disaster if $cop_list *itself* has an INLINE pragma. +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] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -297,16 +322,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 @@ -318,9 +343,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 { @@ -340,27 +365,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 @@ -393,12 +397,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 } @@ -525,7 +529,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 @@ -534,18 +538,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 }) @@ -558,6 +562,18 @@ 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) @@ -582,7 +598,7 @@ tc_inst_decl2 :: Id -> InstBindings Name -> TcM (LHsBinds Id) -- 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) +tc_inst_decl2 dfun_id (NewTypeDerived coi _) = do { let rigid_info = InstSkol origin = SigOrigin rigid_info inst_ty = idType dfun_id @@ -648,7 +664,7 @@ tc_inst_decl2 dfun_id (NewTypeDerived coi) ; return (unitBag $ noLoc $ AbsBinds inst_tvs' (map instToVar dfun_dicts) - [(inst_tvs', dfun_id, instToId this_dict, [])] + [(inst_tvs', dfun_id, instToId this_dict, noSpecPrags)] (dict_bind `consBag` sc_binds)) } where ----------------------- @@ -689,9 +705,9 @@ tc_inst_decl2 dfun_id (NewTypeDerived coi) -- 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 + = 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 @@ -734,7 +750,7 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) ; spec_inst_prags <- mapM (wrapLocM (tcSpecInst dfun_id)) spec_inst_sigs -- Typecheck the methods - ; let prag_fn = mkPragFun uprags + ; let prag_fn = mkPragFun uprags monobinds tc_meth = tcInstanceMethod loc standalone_deriv clas inst_tyvars' dfun_dicts inst_tys' @@ -758,7 +774,8 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) ; 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) + dict_rhs = foldl mk_app inst_constr sc_meth_ids + sc_meth_ids = sc_ids ++ meth_ids inst_constr = L loc $ wrapId (mkWpTyApps inst_tys') (dataConWrapId dict_constr) -- We don't produce a binding for the dict_constr; instead we @@ -772,26 +789,78 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) 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] - `setInlinePragma` alwaysInlinePragma - | 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) + -- 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 sc_meth_ids) `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) + main_bind = AbsBinds + inst_tyvars' + dfun_lam_vars + [(inst_tyvars', dfun_id_w_fun, this_dict_id, SpecPrags spec_inst_prags)] + (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) + } + +{- + -- Create the result bindings + ; let this_dict_id = instToId this_dict + arg_ids = sc_ids ++ meth_ids + arg_binds = listToBag meth_binds `unionBags` + listToBag sc_binds + ; showLIE (text "instance") + ; case newTyConCo_maybe (classTyCon clas) of + Nothing -- A multi-method class + -> return (unitBag (L loc data_bind) `unionBags` arg_binds) + where + data_dfun_id = dfun_id -- Do not inline; instead give it a magic DFunFunfolding + -- See Note [ClassOp/DFun selection] + `setIdUnfolding` mkDFunUnfolding dict_constr arg_ids + `setInlinePragma` dfunInlinePragma + + data_bind = AbsBinds inst_tyvars' dfun_lam_vars + [(inst_tyvars', data_dfun_id, this_dict_id, spec_inst_prags)] + (unitBag dict_bind) + + dict_bind = mkVarBind this_dict_id dict_rhs + dict_rhs = foldl mk_app inst_constr arg_ids + dict_constr = classDataCon clas + inst_constr = L loc $ wrapId (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 + -- We do this rather than generate an HsCon directly, because + -- it means that the special cases (e.g. dictionary with only one + -- member) are dealt with by the common MkId.mkDataConWrapId code rather + -- than needing to be repeated here. + + 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') + + Just the_nt_co -- (Just co) for a single-method class + -> return (unitBag (L loc nt_bind) `unionBags` arg_binds) + where + nt_dfun_id = dfun_id -- Just let the dfun inline; see Note [Single-method classes] + `setInlinePragma` alwaysInlinePragma + + local_nt_dfun = setIdType this_dict_id inst_ty -- A bit of a hack, but convenient + + nt_bind = AbsBinds [] [] + [([], nt_dfun_id, local_nt_dfun, spec_inst_prags)] + (unitBag (mkVarBind local_nt_dfun (L loc (wrapId nt_cast the_meth_id)))) + + the_meth_id = ASSERT( length arg_ids == 1 ) head arg_ids + nt_cast = WpCast $ mkPiTypes (inst_tyvars' ++ dfun_lam_vars) $ + mkSymCoercion (mkTyConApp the_nt_co inst_tys') +-} ------------------------------ tcSuperClass :: InstLoc -> [TyVar] -> [Inst] @@ -820,7 +889,7 @@ tcSuperClass inst_loc tyvars dicts (this_dict, this_bind) sc_id = instToVar sc_dict sc_op_bind = AbsBinds tyvars (map instToVar dicts) - [(tyvars, sc_op_id, sc_id, [])] + [(tyvars, sc_op_id, sc_id, noSpecPrags)] (this_bind `unionBags` sc_binds) ; return (sc_op_id, noLoc sc_op_bind) } @@ -877,7 +946,7 @@ 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 @@ -910,7 +979,7 @@ tcInstanceMethod :: SrcSpan -> Bool -> Class -> [TcTyVar] -> [Inst] -> [TcType] -> (Inst, LHsBinds Id) -- "This" and its binding -> TcPragFun -- Local prags - -> [LSpecPrag] -- Arising from 'SPECLALISE instance' + -> [Located TcSpecPrag] -- Arising from 'SPECLALISE instance' -> LHsBinds Name -> (Id, DefMeth) -> TcM (Id, LHsBind Id) @@ -935,14 +1004,15 @@ tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys 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) + meth_id (prag_fn sel_name) + ; bind <- 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 } + (SpecPrags (spec_inst_prags ++ spec_prags)) + rn_bind + ; return (meth_id1, bind) } -------------- tc_default :: DefMeth -> TcM (Id, LHsBind Id) @@ -958,7 +1028,7 @@ tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys = do { meth_bind <- mkGenericDefMethBind clas inst_tys sel_id local_meth_name ; tc_body meth_bind } - tc_default DefMeth -- An polymorphic default method + tc_default (DefMeth dm_name) -- An polymorphic default method = do { -- Build the typechecked version directly, -- without calling typecheck_method; -- see Note [Default methods in instances] @@ -966,17 +1036,11 @@ tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys -- 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 + rhs = HsWrap (WpApp (instToId this_dict) <.> mkWpTyApps inst_tys) $ + HsVar dm_id meth_bind = L loc $ VarBind { var_id = local_meth_id , var_rhs = L loc rhs @@ -986,8 +1050,8 @@ tcInstanceMethod loc standalone_deriv clas tyvars dfun_dicts inst_tys -- 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_exports = [( tyvars, meth_id1, local_meth_id + , SpecPrags 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 @@ -1072,7 +1136,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 @@ -1084,8 +1149,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 @@ -1093,33 +1159,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 = + + {-# INLINE op1 #-} + op1 b x = op2 (not b) x + +So for the above example we generate: -Then 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 + +* 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 - b) We use the magic 'inline' Id to ensure that $dmop1 really is - inlined in $cop1, even though - (i) the latter itself has an INLINE pragma - (ii) $dmop1 is not saturated - That is important to allow the mutual recursion between $fooInt and - $cop1 to be broken + It's vital that $dmop1 *is* inlined in this way, to allow the mutual + recursion between $fooInt and $cop1 to be broken -This is all regrettably delicate. +* To communicate the need for an InlineCompulsory to the desugarer + (which makes the Unfoldings), we use the IsDefaultMethod constructor + in TcSpecPrags. %************************************************************************