X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcInstDcls.lhs;h=55fc342e30911e9349b58fb1a7ae0b6a060ab756;hp=1af025e355bd643e9b819973f7e0c755e1b5f04d;hb=786932468faac49aafe20b65eabc8bdf465fbc9d;hpb=9a4c93a59e008ddc376fde5f9eb468b762f0d0a7 diff --git a/compiler/typecheck/TcInstDcls.lhs b/compiler/typecheck/TcInstDcls.lhs index 1af025e..55fc342 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,8 +32,6 @@ import DataCon import Class import Var import CoreUnfold ( mkDFunUnfolding ) --- import CoreUtils ( mkPiTypes ) -import PrelNames ( inlineIdName ) import Id import MkId import Name @@ -412,8 +409,7 @@ 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 []) $ @@ -601,7 +597,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 @@ -667,7 +663,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 ----------------------- @@ -753,7 +749,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' @@ -801,7 +797,7 @@ tc_inst_decl2 dfun_id (VanillaInst monobinds uprags standalone_deriv) main_bind = AbsBinds inst_tyvars' dfun_lam_vars - [(inst_tyvars', dfun_id_w_fun, this_dict_id, spec_inst_prags)] + [(inst_tyvars', dfun_id_w_fun, this_dict_id, SpecPrags spec_inst_prags)] (unitBag dict_bind) ; showLIE (text "instance") @@ -891,7 +887,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) } @@ -948,7 +944,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 @@ -981,7 +977,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) @@ -1006,13 +1002,13 @@ 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) + 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) + (SpecPrags (spec_inst_prags ++ spec_prags)) rn_bind } -------------- @@ -1029,7 +1025,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] @@ -1037,17 +1033,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 @@ -1057,8 +1047,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 @@ -1143,7 +1133,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 @@ -1155,8 +1146,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 @@ -1164,31 +1156,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 - - 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 +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 + + 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. %************************************************************************