\begin{code}
module TcClassDcl ( tcClassDecl1, tcClassDecls2,
- tcMethodBind, mkMethodBind, badMethodErr
+ MethodSpec, tcMethodBind, mkMethodBind, badMethodErr
) where
#include "HsVersions.h"
import HsSyn ( TyClDecl(..), Sig(..), MonoBinds(..),
- HsExpr(..), HsLit(..),
+ HsExpr(..), HsLit(..), Pat(WildPat),
mkSimpleMatch, andMonoBinds, andMonoBindList,
- isClassOpSig, isPragSig,
- getClassDeclSysNames, placeHolderType
+ isClassOpSig, isPragSig,
+ placeHolderType
)
import BasicTypes ( RecFlag(..), StrictnessMark(..) )
-import RnHsSyn ( RenamedTyClDecl,
+import RnHsSyn ( RenamedTyClDecl, RenamedSig,
RenamedClassOpSig, RenamedMonoBinds,
maybeGenericMatch
)
+import RnEnv ( lookupSysName )
import TcHsSyn ( TcMonoBinds )
-import Inst ( Inst, InstOrigin(..), LIE, emptyLIE, plusLIE, plusLIEs,
- instToId, newDicts, newMethod )
+import Inst ( Inst, InstOrigin(..), instToId, newDicts, newMethod )
import TcEnv ( TyThingDetails(..),
tcLookupClass, tcExtendTyVarEnv2,
tcExtendTyVarEnv
import TcUnify ( checkSigTyVars, sigCtxt )
import TcMType ( tcInstTyVars )
import TcType ( Type, TyVarDetails(..), TcType, TcThetaType, TcTyVar,
- mkTyVarTys, mkPredTys, mkClassPred,
- tcIsTyVarTy, tcSplitTyConApp_maybe
+ mkTyVarTys, mkPredTys, mkClassPred, tcSplitSigmaTy, tcSplitFunTys,
+ tcIsTyVarTy, tcSplitTyConApp_maybe, tcSplitForAllTys, tcSplitPhiTy,
+ getClassPredTys_maybe, mkPhiTy
)
-import TcMonad
+import TcRnMonad
import Generics ( mkGenericRhs )
import PrelInfo ( nO_METHOD_BINDING_ERROR_ID )
import Class ( classTyVars, classBigSig, classTyCon,
Class, ClassOpItem, DefMeth (..) )
import TyCon ( tyConGenInfo )
+import Subst ( substTyWith )
import MkId ( mkDictSelId, mkDataConId, mkDataConWrapId, mkDefaultMethodId )
import DataCon ( mkDataCon )
-import Id ( Id, idType, idName, setIdLocalExported )
-import Module ( Module )
+import Id ( Id, idType, idName, mkUserLocal, setIdLocalExported, setInlinePragma )
import Name ( Name, NamedThing(..) )
import NameEnv ( NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv, plusNameEnv )
-import NameSet ( emptyNameSet )
+import NameSet ( emptyNameSet, unitNameSet )
+import OccName ( mkClassTyConOcc, mkClassDataConOcc, mkWorkerOcc,
+ mkSuperDictSelOcc, reportIfUnused )
import Outputable
import Var ( TyVar )
import CmdLineOpts
+import UnicodeUtil ( stringToUtf8 )
import ErrUtils ( dumpIfSet )
-import Util ( count, lengthIs, equalLength )
+import Util ( count, lengthIs, isSingleton )
import Maybes ( seqMaybe )
import Maybe ( isJust )
+import FastString
\end{code}
tcClassDecl1 (ClassDecl {tcdCtxt = context, tcdName = class_name,
tcdTyVars = tyvar_names, tcdFDs = fundeps,
tcdSigs = class_sigs, tcdMeths = def_methods,
- tcdSysNames = sys_names, tcdLoc = src_loc})
+ tcdLoc = src_loc})
= -- LOOK THINGS UP IN THE ENVIRONMENT
- tcLookupClass class_name `thenTc` \ clas ->
+ tcLookupClass class_name `thenM` \ clas ->
let
- tyvars = classTyVars clas
- op_sigs = filter isClassOpSig class_sigs
- op_names = [n | ClassOpSig n _ _ _ <- op_sigs]
- (_, datacon_name, datacon_wkr_name, sc_sel_names) = getClassDeclSysNames sys_names
+ tyvars = classTyVars clas
+ op_sigs = filter isClassOpSig class_sigs
+ op_names = [n | ClassOpSig n _ _ _ <- op_sigs]
in
tcExtendTyVarEnv tyvars $
- checkDefaultBinds clas op_names def_methods `thenTc` \ mb_dm_env ->
+ checkDefaultBinds clas op_names def_methods `thenM` \ mb_dm_env ->
-- CHECK THE CONTEXT
-- The renamer has already checked that the context mentions
-- only the type variable of the class decl.
-- Context is already kind-checked
- ASSERT( equalLength context sc_sel_names )
- tcHsTheta context `thenTc` \ sc_theta ->
+ tcHsTheta context `thenM` \ sc_theta ->
-- CHECK THE CLASS SIGNATURES,
- mapTc (tcClassSig clas tyvars mb_dm_env) op_sigs `thenTc` \ sig_stuff ->
+ mappM (tcClassSig clas tyvars mb_dm_env) op_sigs `thenM` \ sig_stuff ->
-- MAKE THE CLASS DETAILS
+ lookupSysName class_name mkClassDataConOcc `thenM` \ datacon_name ->
+ lookupSysName datacon_name mkWorkerOcc `thenM` \ datacon_wkr_name ->
+ mapM (lookupSysName class_name . mkSuperDictSelOcc)
+ [1..length context] `thenM` \ sc_sel_names ->
+ -- We number off the superclass selectors, 1, 2, 3 etc so that we
+ -- can construct names for the selectors. Thus
+ -- class (C a, C b) => D a b where ...
+ -- gives superclass selectors
+ -- D_sc1, D_sc2
+ -- (We used to call them D_C, but now we can have two different
+ -- superclasses both called C!)
+ lookupSysName class_name mkClassTyConOcc `thenM` \ tycon_name ->
let
(op_tys, op_items) = unzip sig_stuff
sc_tys = mkPredTys sc_theta
dict_con_id = mkDataConId datacon_wkr_name dict_con
dict_wrap_id = mkDataConWrapId dict_con
in
- returnTc (class_name, ClassDetails sc_theta sc_sel_ids op_items dict_con)
+ returnM (class_name, ClassDetails sc_theta sc_sel_ids op_items dict_con tycon_name)
\end{code}
\begin{code}
-- But do all this only for source binds
checkDefaultBinds clas ops Nothing
- = returnTc Nothing
+ = returnM Nothing
checkDefaultBinds clas ops (Just mbs)
- = go mbs `thenTc` \ dm_env ->
- returnTc (Just dm_env)
+ = go mbs `thenM` \ dm_env ->
+ returnM (Just dm_env)
where
- go EmptyMonoBinds = returnTc emptyNameEnv
+ go EmptyMonoBinds = returnM emptyNameEnv
go (AndMonoBinds b1 b2)
- = go b1 `thenTc` \ dm_info1 ->
- go b2 `thenTc` \ dm_info2 ->
- returnTc (dm_info1 `plusNameEnv` dm_info2)
+ = go b1 `thenM` \ dm_info1 ->
+ go b2 `thenM` \ dm_info2 ->
+ returnM (dm_info1 `plusNameEnv` dm_info2)
go (FunMonoBind op _ matches loc)
- = tcAddSrcLoc loc $
+ = addSrcLoc loc $
-- Check that the op is from this class
- checkTc (op `elem` ops) (badMethodErr clas op) `thenTc_`
+ checkTc (op `elem` ops) (badMethodErr clas op) `thenM_`
-- Check that all the defns ar generic, or none are
- checkTc (all_generic || none_generic) (mixedGenericErr op) `thenTc_`
+ checkTc (all_generic || none_generic) (mixedGenericErr op) `thenM_`
- returnTc (unitNameEnv op all_generic)
+ returnM (unitNameEnv op all_generic)
where
n_generic = count (isJust . maybeGenericMatch) matches
none_generic = n_generic == 0
tcClassSig clas clas_tyvars maybe_dm_env
(ClassOpSig op_name sig_dm op_ty src_loc)
- = tcAddSrcLoc src_loc $
+ = addSrcLoc src_loc $
-- Check the type signature. NB that the envt *already has*
-- bindings for the type variables; see comments in TcTyAndClassDcls.
- tcHsType op_ty `thenTc` \ local_ty ->
+ tcHsType op_ty `thenM` \ local_ty ->
let
theta = [mkClassPred clas (mkTyVarTys clas_tyvars)]
Just True -> GenDefMeth
Just False -> DefMeth dm_name
in
- returnTc (local_ty, (sel_id, dm_info))
+ returnM (local_ty, (sel_id, dm_info))
\end{code}
each local class decl.
\begin{code}
-tcClassDecls2 :: Module -> [RenamedTyClDecl] -> NF_TcM (LIE, TcMonoBinds, [Id])
+tcClassDecls2 :: [RenamedTyClDecl] -> TcM (TcMonoBinds, [Id])
-tcClassDecls2 this_mod decls
+tcClassDecls2 decls
= foldr combine
- (returnNF_Tc (emptyLIE, EmptyMonoBinds, []))
+ (returnM (EmptyMonoBinds, []))
[tcClassDecl2 cls_decl | cls_decl@(ClassDecl {tcdMeths = Just _}) <- decls]
-- The 'Just' picks out source ClassDecls
where
- combine tc1 tc2 = tc1 `thenNF_Tc` \ (lie1, binds1, ids1) ->
- tc2 `thenNF_Tc` \ (lie2, binds2, ids2) ->
- returnNF_Tc (lie1 `plusLIE` lie2,
- binds1 `AndMonoBinds` binds2,
- ids1 ++ ids2)
+ combine tc1 tc2 = tc1 `thenM` \ (binds1, ids1) ->
+ tc2 `thenM` \ (binds2, ids2) ->
+ returnM (binds1 `AndMonoBinds` binds2,
+ ids1 ++ ids2)
\end{code}
@tcClassDecl2@ generates bindings for polymorphic default methods
\begin{code}
tcClassDecl2 :: RenamedTyClDecl -- The class declaration
- -> NF_TcM (LIE, TcMonoBinds, [Id])
+ -> TcM (TcMonoBinds, [Id])
tcClassDecl2 (ClassDecl {tcdName = class_name, tcdSigs = sigs,
tcdMeths = Just default_binds, tcdLoc = src_loc})
= -- The 'Just' picks out source ClassDecls
- recoverNF_Tc (returnNF_Tc (emptyLIE, EmptyMonoBinds, [])) $
- tcAddSrcLoc src_loc $
- tcLookupClass class_name `thenNF_Tc` \ clas ->
+ recoverM (returnM (EmptyMonoBinds, [])) $
+ addSrcLoc src_loc $
+ tcLookupClass class_name `thenM` \ clas ->
-- We make a separate binding for each default method.
-- At one time I used a single AbsBinds for all of them, thus
prags = filter isPragSig sigs
tc_dm = tcDefMeth clas tyvars default_binds prags
in
- mapAndUnzip3Tc tc_dm op_items `thenTc` \ (defm_binds, const_lies, dm_ids_s) ->
+ mapAndUnzipM tc_dm op_items `thenM` \ (defm_binds, dm_ids_s) ->
- returnTc (plusLIEs const_lies, andMonoBindList defm_binds, concat dm_ids_s)
+ returnM (andMonoBindList defm_binds, concat dm_ids_s)
-tcDefMeth clas tyvars binds_in prags (_, NoDefMeth) = returnTc (EmptyMonoBinds, emptyLIE, [])
-tcDefMeth clas tyvars binds_in prags (_, GenDefMeth) = returnTc (EmptyMonoBinds, emptyLIE, [])
+tcDefMeth clas tyvars binds_in prags (_, NoDefMeth) = returnM (EmptyMonoBinds, [])
+tcDefMeth clas tyvars binds_in prags (_, GenDefMeth) = returnM (EmptyMonoBinds, [])
-- Generate code for polymorphic default methods only
-- (Generic default methods have turned into instance decls by now.)
-- This is incompatible with Hugs, which expects a polymorphic
-- (If necessary we can fix that, but we don't have a convenient Id to hand.)
tcDefMeth clas tyvars binds_in prags op_item@(sel_id, DefMeth dm_name)
- = tcInstTyVars ClsTv tyvars `thenNF_Tc` \ (clas_tyvars, inst_tys, _) ->
+ = tcInstTyVars ClsTv tyvars `thenM` \ (clas_tyvars, inst_tys, _) ->
let
dm_ty = idType sel_id -- Same as dict selector!
-- The default method's type should really come from the
-- TyGenNever (in MkId). Ugh! KSW 1999-09.
theta = [mkClassPred clas inst_tys]
- dm_id = mkDefaultMethodId dm_name dm_ty
- local_dm_id = setIdLocalExported dm_id
- -- Reason for setIdLocalExported: see notes with MkId.mkDictFunId
- xtve = tyvars `zip` clas_tyvars
+ local_dm_id = mkDefaultMethodId dm_name dm_ty
+ xtve = tyvars `zip` clas_tyvars
in
- newDicts origin theta `thenNF_Tc` \ [this_dict] ->
+ newDicts origin theta `thenM` \ [this_dict] ->
- mkMethodBind origin clas inst_tys binds_in op_item `thenTc` \ (dm_inst, meth_info) ->
- tcMethodBind xtve clas_tyvars theta
- [this_dict] meth_info `thenTc` \ (defm_bind, insts_needed) ->
+ mkMethodBind origin clas inst_tys binds_in op_item `thenM` \ (_, meth_info) ->
+ getLIE (tcMethodBind xtve clas_tyvars theta
+ [this_dict] prags meth_info) `thenM` \ (defm_bind, insts_needed) ->
- tcAddErrCtxt (defltMethCtxt clas) $
+ addErrCtxt (defltMethCtxt clas) $
-- Check the context
tcSimplifyCheck
(ptext SLIT("class") <+> ppr clas)
clas_tyvars
[this_dict]
- insts_needed `thenTc` \ (const_lie, dict_binds) ->
+ insts_needed `thenM` \ dict_binds ->
-- Simplification can do unification
- checkSigTyVars clas_tyvars `thenTc` \ clas_tyvars' ->
+ checkSigTyVars clas_tyvars `thenM` \ clas_tyvars' ->
let
+ (_,dm_inst_id,_) = meth_info
full_bind = AbsBinds
clas_tyvars'
[instToId this_dict]
- [(clas_tyvars', local_dm_id, instToId dm_inst)]
+ [(clas_tyvars', local_dm_id, dm_inst_id)]
emptyNameSet -- No inlines (yet)
(dict_binds `andMonoBinds` defm_bind)
in
- returnTc (full_bind, const_lie, [dm_id])
+ returnM (full_bind, [local_dm_id])
where
origin = ClassDeclOrigin
\end{code}
tyvar sets.
\begin{code}
+type MethodSpec = (Id, -- Global selector Id
+ Id, -- Local Id (class tyvars instantiated)
+ RenamedMonoBinds) -- Binding for the method
+
tcMethodBind
:: [(TyVar,TcTyVar)] -- Bindings for type environment
-> [TcTyVar] -- Instantiated type variables for the
-> TcThetaType -- Available theta; it's just used for the error message
-> [Inst] -- Available from context, used to simplify constraints
-- from the method body
- -> (Id, TcSigInfo, RenamedMonoBinds) -- Details of this method
- -> TcM (TcMonoBinds, LIE)
+ -> [RenamedSig] -- Pragmas (e.g. inline pragmas)
+ -> MethodSpec -- Details of this method
+ -> TcM TcMonoBinds
-tcMethodBind xtve inst_tyvars inst_theta avail_insts
- (sel_id, meth_sig, meth_bind)
- =
- -- Check the bindings; first adding inst_tyvars to the envt
+tcMethodBind xtve inst_tyvars inst_theta avail_insts prags
+ (sel_id, meth_id, meth_bind)
+ = -- Check the bindings; first adding inst_tyvars to the envt
-- so that we don't quantify over them in nested places
+ mkTcSig meth_id `thenM` \ meth_sig ->
+
tcExtendTyVarEnv2 xtve (
- tcAddErrCtxt (methodCtxt sel_id) $
- tcMonoBinds meth_bind [meth_sig] NonRecursive
- ) `thenTc` \ (meth_bind, meth_lie, _, _) ->
+ addErrCtxt (methodCtxt sel_id) $
+ getLIE (tcMonoBinds meth_bind [meth_sig] NonRecursive)
+ ) `thenM` \ ((meth_bind, _, _), meth_lie) ->
-- Now do context reduction. We simplify wrt both the local tyvars
-- and the ones of the class/instance decl, so that there is
let
TySigInfo meth_id meth_tvs meth_theta _ local_meth_id _ _ = meth_sig
in
- tcAddErrCtxtM (sigCtxt sel_id inst_tyvars inst_theta (idType meth_id)) $
- newDicts SignatureOrigin meth_theta `thenNF_Tc` \ meth_dicts ->
+ addErrCtxtM (sigCtxt sel_id inst_tyvars inst_theta (idType meth_id)) $
+ newDicts SignatureOrigin meth_theta `thenM` \ meth_dicts ->
let
all_tyvars = meth_tvs ++ inst_tyvars
all_insts = avail_insts ++ meth_dicts
in
tcSimplifyCheck
(ptext SLIT("class or instance method") <+> quotes (ppr sel_id))
- all_tyvars all_insts meth_lie `thenTc` \ (lie, lie_binds) ->
+ all_tyvars all_insts meth_lie `thenM` \ lie_binds ->
- checkSigTyVars all_tyvars `thenTc` \ all_tyvars' ->
+ checkSigTyVars all_tyvars `thenM` \ all_tyvars' ->
let
+ -- Attach inline pragmas as appropriate
+ (final_meth_id, inlines)
+ | (InlineSig inl _ phase _ : _) <- filter is_inline prags
+ = (meth_id `setInlinePragma` phase,
+ if inl then unitNameSet (idName meth_id) else emptyNameSet)
+ | otherwise
+ = (meth_id, emptyNameSet)
+
+ is_inline (InlineSig _ name _ _) = name == idName sel_id
+ is_inline other = False
+
meth_tvs' = take (length meth_tvs) all_tyvars'
poly_meth_bind = AbsBinds meth_tvs'
(map instToId meth_dicts)
- [(meth_tvs', meth_id, local_meth_id)]
- emptyNameSet -- Inlines?
+ [(meth_tvs', final_meth_id, local_meth_id)]
+ inlines
(lie_binds `andMonoBinds` meth_bind)
in
- returnTc (poly_meth_bind, lie)
+ returnM poly_meth_bind
mkMethodBind :: InstOrigin
-> Class -> [TcType] -- Class and instance types
-> RenamedMonoBinds -- Method binding (pick the right one from in here)
-> ClassOpItem
- -> TcM (Inst, -- Method inst
- (Id, -- Global selector Id
- TcSigInfo, -- Signature
- RenamedMonoBinds)) -- Binding for the method
+ -> TcM (Maybe Inst, -- Method inst
+ MethodSpec)
+-- Find the binding for the specified method, or make
+-- up a suitable default method if it isn't there
mkMethodBind origin clas inst_tys meth_binds (sel_id, dm_info)
- = tcGetSrcLoc `thenNF_Tc` \ loc ->
- newMethod origin sel_id inst_tys `thenNF_Tc` \ meth_inst ->
+ = mkMethId origin clas sel_id inst_tys `thenM` \ (mb_inst, meth_id) ->
let
- meth_id = instToId meth_inst
meth_name = idName meth_id
in
-- Figure out what method binding to use
-- If the user suppplied one, use it, else construct a default one
+ getSrcLocM `thenM` \ loc ->
(case find_bind (idName sel_id) meth_name meth_binds of
- Just user_bind -> returnTc user_bind
- Nothing -> mkDefMethRhs origin clas inst_tys sel_id loc dm_info `thenTc` \ rhs ->
- returnTc (FunMonoBind meth_name False -- Not infix decl
- [mkSimpleMatch [] rhs placeHolderType loc] loc)
- ) `thenTc` \ meth_bind ->
-
- mkTcSig meth_id loc `thenNF_Tc` \ meth_sig ->
-
- returnTc (meth_inst, (sel_id, meth_sig, meth_bind))
-
+ Just user_bind -> returnM user_bind
+ Nothing -> mkDefMethRhs origin clas inst_tys sel_id loc dm_info `thenM` \ rhs ->
+ returnM (FunMonoBind meth_name False -- Not infix decl
+ [mkSimpleMatch [] rhs placeHolderType loc] loc)
+ ) `thenM` \ meth_bind ->
+
+ returnM (mb_inst, (sel_id, meth_id, meth_bind))
+
+mkMethId :: InstOrigin -> Class
+ -> Id -> [TcType] -- Selector, and instance types
+ -> TcM (Maybe Inst, Id)
+
+-- mkMethId instantiates the selector Id at the specified types
+-- THe
+mkMethId origin clas sel_id inst_tys
+ = let
+ (tyvars,rho) = tcSplitForAllTys (idType sel_id)
+ rho_ty = ASSERT( length tyvars == length inst_tys )
+ substTyWith tyvars inst_tys rho
+ (preds,tau) = tcSplitPhiTy rho_ty
+ first_pred = head preds
+ in
+ -- The first predicate should be of form (C a b)
+ -- where C is the class in question
+ ASSERT( not (null preds) &&
+ case getClassPredTys_maybe first_pred of
+ { Just (clas1,tys) -> clas == clas1 ; Nothing -> False }
+ )
+ if isSingleton preds then
+ -- If it's the only one, make a 'method'
+ getInstLoc origin `thenM` \ inst_loc ->
+ newMethod inst_loc sel_id inst_tys preds tau `thenM` \ meth_inst ->
+ returnM (Just meth_inst, instToId meth_inst)
+ else
+ -- If it's not the only one we need to be careful
+ -- For example, given 'op' defined thus:
+ -- class Foo a where
+ -- op :: (?x :: String) => a -> a
+ -- (mkMethId op T) should return an Inst with type
+ -- (?x :: String) => T -> T
+ -- That is, the class-op's context is still there.
+ -- BUT: it can't be a Method any more, because it breaks
+ -- INVARIANT 2 of methods. (See the data decl for Inst.)
+ newUnique `thenM` \ uniq ->
+ getSrcLocM `thenM` \ loc ->
+ let
+ real_tau = mkPhiTy (tail preds) tau
+ meth_id = mkUserLocal (getOccName sel_id) uniq real_tau loc
+ in
+ returnM (Nothing, meth_id)
-- The user didn't supply a method binding,
-- so we have to make up a default binding
-- The RHS of a default method depends on the default-method info
mkDefMethRhs origin clas inst_tys sel_id loc (DefMeth dm_name)
= -- An polymorphic default method
- returnTc (HsVar dm_name)
+ traceRn (text "mkDefMeth" <+> ppr dm_name) `thenM_`
+ returnM (HsVar dm_name)
mkDefMethRhs origin clas inst_tys sel_id loc NoDefMeth
= -- No default method
-- Warn only if -fwarn-missing-methods
- doptsTc Opt_WarnMissingMethods `thenNF_Tc` \ warn ->
- warnTc (isInstDecl origin && warn)
- (omittedMethodWarn sel_id) `thenNF_Tc_`
- returnTc error_rhs
+ doptM Opt_WarnMissingMethods `thenM` \ warn ->
+ warnTc (isInstDecl origin
+ && warn
+ && reportIfUnused (getOccName sel_id))
+ (omittedMethodWarn sel_id) `thenM_`
+ returnM error_rhs
where
- error_rhs = HsApp (HsVar (getName nO_METHOD_BINDING_ERROR_ID))
- (HsLit (HsString (_PK_ error_msg)))
+ error_rhs = HsLam (mkSimpleMatch wild_pats simple_rhs placeHolderType loc)
+ simple_rhs = HsApp (HsVar (getName nO_METHOD_BINDING_ERROR_ID))
+ (HsLit (HsStringPrim (mkFastString (stringToUtf8 error_msg))))
error_msg = showSDoc (hcat [ppr loc, text "|", ppr sel_id ])
+ -- When the type is of form t1 -> t2 -> t3
+ -- make a default method like (\ _ _ -> noMethBind "blah")
+ -- rather than simply (noMethBind "blah")
+ -- Reason: if t1 or t2 are higher-ranked types we get n
+ -- silly ambiguity messages.
+ -- Example: f :: (forall a. Eq a => a -> a) -> Int
+ -- f = error "urk"
+ -- Here, tcSub tries to force (error "urk") to have the right type,
+ -- thus: f = \(x::forall a. Eq a => a->a) -> error "urk" (x t)
+ -- where 't' is fresh ty var. This leads directly to "ambiguous t".
+ --
+ -- NB: technically this changes the meaning of the default-default
+ -- method slightly, because `seq` can see the lambdas. Oh well.
+ (_,_,tau1) = tcSplitSigmaTy (idType sel_id)
+ (_,_,tau2) = tcSplitSigmaTy tau1
+ -- Need two splits because the selector can have a type like
+ -- forall a. Foo a => forall b. Eq b => ...
+ (arg_tys, _) = tcSplitFunTys tau2
+ wild_pats = [WildPat placeHolderType | ty <- arg_tys]
mkDefMethRhs origin clas inst_tys sel_id loc GenDefMeth
= -- A generic default method
ASSERT( isInstDecl origin ) -- We never get here from a class decl
checkTc (isJust maybe_tycon)
- (badGenericInstance sel_id (notSimple inst_tys)) `thenTc_`
+ (badGenericInstance sel_id (notSimple inst_tys)) `thenM_`
checkTc (isJust (tyConGenInfo tycon))
- (badGenericInstance sel_id (notGeneric tycon)) `thenTc_`
+ (badGenericInstance sel_id (notGeneric tycon)) `thenM_`
- ioToTc (dumpIfSet opt_PprStyle_Debug "Generic RHS" stuff) `thenNF_Tc_`
- returnTc rhs
+ ioToTcRn (dumpIfSet opt_PprStyle_Debug "Generic RHS" stuff) `thenM_`
+ returnM rhs
where
rhs = mkGenericRhs sel_id clas_tyvar tycon
projects / ghc-hetmet.git / blobdiff