import TcBinds
import TcTyClsDecls
import TcClassDcl
+import TcPat( addInlinePrags )
import TcRnMonad
import TcMType
import TcType
import DataCon
import Class
import Var
-import VarSet ( emptyVarSet )
import CoreUtils ( mkPiTypes )
import CoreUnfold ( mkDFunUnfolding )
import CoreSyn ( Expr(Var) )
-- to use in each method binding
-- 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
+ EvDFunApp dfun_id (mkTyVarTys inst_tyvars') dfun_ev_vars []
+ -- Empty dependencies [], since it only
+ -- depends on "given" things
-- Deal with 'SPECIALISE instance' pragmas
-- See Note [SPECIALISE instance pragmas]
mapAndUnzipM tc_sc (sc_sels `zip` sc_dicts)
-- NOT FINISHED!
- ; (_eq_sc_binds, sc_eq_vars) <- checkConstraints InstSkol emptyVarSet
+ ; (_eq_sc_binds, sc_eq_vars) <- checkConstraints InstSkol
inst_tyvars' dfun_ev_vars $
emitWanteds ScOrigin sc_eqs
------------------------------
tcSuperClass :: [TyVar] -> [EvVar]
-> EvBind
- -> (Id, PredType) -> TcM (Id, LHsBind Id)
+ -> (Id, PredType) -> TcM (Id, LHsBind Id)
-- Build a top level decl like
-- sc_op = /\a \d. let this = ... in
-- let sc = ... in
-- The "this" part is just-in-case (discarded if not used)
-- See Note [Recursive superclasses]
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!!
+ self_ev_bind
+ (sc_sel, sc_pred)
+ = do { sc_dict <- newWantedEvVar sc_pred
+ ; ev_binds <- simplifySuperClass tyvars dicts sc_dict self_ev_bind
; uniq <- newUnique
; let sc_op_ty = mkForAllTys tyvars $ mkPiTypes dicts (varType sc_dict)
, var_rhs = L noSrcSpan $ wrapId sc_wrapper sc_dict }
sc_wrapper = mkWpTyLams tyvars
<.> mkWpLams dicts
- <.> mkWpLet (EvBinds (unitBag self_ev_bind))
- <.> mkWpLet ev_binds
+ <.> mkWpLet ev_binds
; return (sc_op_id, noLoc sc_op_bind) }
\end{code}
; let spec_ty = mkSigmaTy tyvars theta tau
; co_fn <- tcSubType (SpecPragOrigin name) (SigSkol SpecInstCtxt)
(idType dfun_id) spec_ty
- ; return (SpecPrag co_fn defaultInlinePragma) }
+ ; return (SpecPrag dfun_id co_fn defaultInlinePragma) }
where
spec_ctxt prag = hang (ptext (sLit "In the SPECIALISE pragma")) 2 (ppr prag)
= add_meth_ctxt sel_id 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))
-
+ ; let prags = prag_fn (idName sel_id)
+ ; meth_id1 <- addInlinePrags meth_id prags
+ ; spec_prags <- tcSpecPrags meth_id1 prags
; bind <- tcInstanceMethodBody InstSkol
- tyvars dfun_ev_vars
- mb_dict_ev
- meth_id1 local_meth_id
- meth_sig_fn
- (SpecPrags (spec_inst_prags ++ spec_prags))
+ tyvars dfun_ev_vars mb_dict_ev
+ meth_id1 local_meth_id meth_sig_fn
+ (mk_meth_spec_prags meth_id1 spec_prags)
rn_bind
; return (meth_id1, bind) }
bind = AbsBinds { abs_tvs = tyvars, abs_ev_vars = dfun_ev_vars
, abs_exports = [( tyvars, meth_id1, local_meth_id
- , SpecPrags spec_inst_prags)]
+ , mk_meth_spec_prags meth_id1 [])]
, abs_ev_binds = EvBinds (unitBag self_dict_ev)
, abs_binds = unitBag meth_bind }
-- Default methods in an instance declaration can't have their own
; return (meth_id1, L loc bind) }
----------------------
+ mk_meth_spec_prags :: Id -> [LTcSpecPrag] -> TcSpecPrags
+ -- Adapt the SPECIALISE pragmas to work for this method Id
+ -- There are two sources:
+ -- * spec_inst_prags: {-# SPECIALISE instance :: <blah> #-}
+ -- These ones have the dfun inside, but [perhaps surprisingly]
+ -- the correct wrapper
+ -- * spec_prags_for_me: {-# SPECIALISE op :: <blah> #-}
+ mk_meth_spec_prags meth_id spec_prags_for_me
+ = SpecPrags (spec_prags_for_me ++
+ [ L loc (SpecPrag meth_id wrap inl)
+ | L loc (SpecPrag _ wrap inl) <- spec_inst_prags])
+
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
-- by the constraint solver, since the <context> may be
-- user-specified.
- = do { rep_d_stuff <- checkConstraints InstSkol emptyVarSet tyvars dfun_ev_vars $
+ = do { rep_d_stuff <- checkConstraints InstSkol tyvars dfun_ev_vars $
emitWanted ScOrigin rep_pred
; mapAndUnzipM (tc_item rep_d_stuff) op_items }
derivBindCtxt :: Id -> Class -> [Type ] -> LHsBind Name -> SDoc
derivBindCtxt sel_id clas tys _bind
- = vcat [ ptext (sLit "When typechecking the code for ") <+> ppr sel_id
+ = vcat [ ptext (sLit "When typechecking the code for ") <+> quotes (ppr sel_id)
, nest 2 (ptext (sLit "in a standalone derived instance for")
<+> quotes (pprClassPred clas tys) <> colon)
, nest 2 $ ptext (sLit "To see the code I am typechecking, use -ddump-deriv") ]
projects / ghc-hetmet.git / blobdiff