\section[TcClassDcl]{Typechecking class declarations}
\begin{code}
-module TcClassDcl ( tcClassDecl1, checkValidClass, tcClassDecls2,
- tcMethodBind, badMethodErr
+module TcClassDcl ( tcClassDecl1, tcClassDecls2,
+ 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 ( TopLevelFlag(..), RecFlag(..), StrictnessMark(..) )
-import RnHsSyn ( RenamedTyClDecl,
+import BasicTypes ( RecFlag(..), StrictnessMark(..) )
+import RnHsSyn ( RenamedTyClDecl, RenamedSig,
RenamedClassOpSig, RenamedMonoBinds,
- RenamedSig, maybeGenericMatch
+ 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, tcExtendTyVarEnvForMeths, tcExtendGlobalTyVars,
- tcExtendLocalValEnv, tcExtendTyVarEnv
+ tcLookupClass, tcExtendTyVarEnv2,
+ tcExtendTyVarEnv
)
-import TcBinds ( tcBindWithSigs, tcSpecSigs )
-import TcMonoType ( tcHsType, tcHsTheta, mkTcSig )
-import TcSimplify ( tcSimplifyCheck, bindInstsOfLocalFuns )
+import TcBinds ( tcMonoBinds )
+import TcMonoType ( TcSigInfo(..), tcHsType, tcHsTheta, mkTcSig )
+import TcSimplify ( tcSimplifyCheck )
import TcUnify ( checkSigTyVars, sigCtxt )
-import TcMType ( tcInstSigTyVars, checkValidTheta, checkValidType, SourceTyCtxt(..), UserTypeCtxt(..) )
+import TcMType ( tcInstTyVars )
import TcType ( Type, TyVarDetails(..), TcType, TcThetaType, TcTyVar,
- mkTyVarTys, mkPredTys, mkClassPred,
- tcIsTyVarTy, tcSplitTyConApp_maybe, tcSplitSigmaTy
+ mkTyVarTys, mkPredTys, mkClassPred, tcSplitSigmaTy, tcSplitFunTys,
+ tcIsTyVarTy, tcSplitTyConApp_maybe, tcSplitForAllTys, tcSplitPhiTy,
+ getClassPredTys_maybe, mkPhiTy
)
-import TcMonad
-import Generics ( mkGenericRhs, validGenericMethodType )
+import TcRnMonad
+import Generics ( mkGenericRhs )
import PrelInfo ( nO_METHOD_BINDING_ERROR_ID )
-import Class ( classTyVars, classBigSig, classTyCon, className,
+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 VarSet ( mkVarSet, emptyVarSet )
import CmdLineOpts
+import UnicodeUtil ( stringToUtf8 )
import ErrUtils ( dumpIfSet )
-import Util ( count, isSingleton, lengthIs, equalLength )
-import Maybes ( seqMaybe, maybeToBool )
+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 (maybeToBool . maybeGenericMatch) matches
+ n_generic = count (isJust . maybeGenericMatch) matches
none_generic = n_generic == 0
all_generic = matches `lengthIs` n_generic
\end{code}
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))
-\end{code}
-
-checkValidClass is called once the mutually-recursive knot has been
-tied, so we can look at things freely.
-
-\begin{code}
-checkValidClass :: Class -> TcM ()
-checkValidClass cls
- = -- CHECK ARITY 1 FOR HASKELL 1.4
- doptsTc Opt_GlasgowExts `thenTc` \ gla_exts ->
-
- -- Check that the class is unary, unless GlaExs
- checkTc (not (null tyvars)) (nullaryClassErr cls) `thenTc_`
- checkTc (gla_exts || unary) (classArityErr cls) `thenTc_`
-
- -- Check the super-classes
- checkValidTheta (ClassSCCtxt (className cls)) theta `thenTc_`
-
- -- Check the class operations
- mapTc_ check_op op_stuff `thenTc_`
-
- -- Check that if the class has generic methods, then the
- -- class has only one parameter. We can't do generic
- -- multi-parameter type classes!
- checkTc (unary || no_generics) (genericMultiParamErr cls)
-
- where
- (tyvars, theta, _, op_stuff) = classBigSig cls
- unary = isSingleton tyvars
- no_generics = null [() | (_, GenDefMeth) <- op_stuff]
-
- check_op (sel_id, dm)
- = checkValidTheta SigmaCtxt (tail theta) `thenTc_`
- -- The 'tail' removes the initial (C a) from the
- -- class itself, leaving just the method type
-
- checkValidType (FunSigCtxt op_name) tau `thenTc_`
-
- -- Check that for a generic method, the type of
- -- the method is sufficiently simple
- checkTc (dm /= GenDefMeth || validGenericMethodType op_ty)
- (badGenericMethodType op_name op_ty)
- where
- op_name = idName sel_id
- op_ty = idType sel_id
- (_,theta,tau) = tcSplitSigmaTy op_ty
+ 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)
- = tcInstSigTyVars ClsTv tyvars `thenNF_Tc` \ clas_tyvars ->
+ = 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
-- of types of default methods (and dict funs) by annotating them
-- TyGenNever (in MkId). Ugh! KSW 1999-09.
- inst_tys = mkTyVarTys clas_tyvars
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
+ 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] ->
- tcExtendTyVarEnvForMeths tyvars clas_tyvars (
- tcMethodBind clas origin clas_tyvars inst_tys theta
- binds_in prags False op_item
- ) `thenTc` \ (defm_bind, insts_needed, local_dm_inst) ->
+ 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 emptyVarSet `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 local_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
- :: Class
- -> InstOrigin
+ :: [(TyVar,TcTyVar)] -- Bindings for type environment
-> [TcTyVar] -- Instantiated type variables for the
- -- enclosing class/instance decl.
- -- They'll be signature tyvars, and we
- -- want to check that they don't get bound
- -> [TcType] -- Instance types
- -> TcThetaType -- Available theta; this could be used to check
- -- the method signature, but actually that's done by
- -- the caller; here, it's just used for the error message
- -> RenamedMonoBinds -- Method binding (pick the right one from in here)
- -> [RenamedSig] -- Pramgas (just for this one)
- -> Bool -- True <=> This method is from an instance declaration
- -> ClassOpItem -- The method selector and default-method Id
- -> TcM (TcMonoBinds, LIE, Inst)
-
-tcMethodBind clas origin inst_tyvars inst_tys inst_theta
- meth_binds prags is_inst_decl (sel_id, dm_info)
- = tcGetSrcLoc `thenNF_Tc` \ loc ->
- newMethod origin sel_id inst_tys `thenNF_Tc` \ meth ->
+ -- enclosing class/instance decl.
+ -- They'll be signature tyvars, and we
+ -- want to check that they don't get bound
+ -- Always equal the range of the type envt
+ -> TcThetaType -- Available theta; it's just used for the error message
+ -> [Inst] -- Available from context, used to simplify constraints
+ -- from the method body
+ -> [RenamedSig] -- Pragmas (e.g. inline pragmas)
+ -> MethodSpec -- Details of this method
+ -> TcM TcMonoBinds
+
+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 (
+ 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
+ -- no problem with
+ -- class C a where
+ -- op :: Eq a => a -> b -> a
+ --
+ -- We do this for each method independently to localise error messages
+
+ let
+ TySigInfo meth_id meth_tvs meth_theta _ local_meth_id _ _ = meth_sig
+ in
+ 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 `thenM` \ lie_binds ->
+
+ 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', final_meth_id, local_meth_id)]
+ inlines
+ (lie_binds `andMonoBinds` meth_bind)
+ in
+ returnM poly_meth_bind
+
+
+mkMethodBind :: InstOrigin
+ -> Class -> [TcType] -- Class and instance types
+ -> RenamedMonoBinds -- Method binding (pick the right one from in here)
+ -> ClassOpItem
+ -> 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)
+ = mkMethId origin clas sel_id inst_tys `thenM` \ (mb_inst, meth_id) ->
let
- meth_id = instToId meth
meth_name = idName meth_id
- meth_prags = find_prags (idName sel_id) meth_name prags
in
- mkTcSig meth_id loc `thenNF_Tc` \ sig_info ->
-
-- 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 is_inst_decl 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 ->
- -- Check the bindings; first add inst_tyvars to the envt
- -- so that we don't quantify over them in nested places
- -- The *caller* put the class/inst decl tyvars into the envt
- tcExtendGlobalTyVars (mkVarSet inst_tyvars)
- (tcAddErrCtxt (methodCtxt sel_id) $
- tcBindWithSigs NotTopLevel meth_bind
- [sig_info] meth_prags NonRecursive
- ) `thenTc` \ (binds, insts, _) ->
-
- tcExtendLocalValEnv [(meth_name, meth_id)]
- (tcSpecSigs meth_prags) `thenTc` \ (prag_binds1, prag_lie) ->
-
- -- The prag_lie for a SPECIALISE pragma will mention the function
- -- itself, so we have to simplify them away right now lest they float
- -- outwards!
- bindInstsOfLocalFuns prag_lie [meth_id] `thenTc` \ (prag_lie', prag_binds2) ->
-
- -- Now check that the instance type variables
- -- (or, in the case of a class decl, the class tyvars)
- -- have not been unified with anything in the environment
- --
- -- We do this for each method independently to localise error messages
- -- ...and this is why the call to tcExtendGlobalTyVars must be here
- -- rather than in the caller
- tcAddErrCtxt (ptext SLIT("When checking the type of class method")
- <+> quotes (ppr sel_id)) $
- tcAddErrCtxtM (sigCtxt inst_tyvars inst_theta (idType meth_id)) $
- checkSigTyVars inst_tyvars emptyVarSet `thenTc_`
-
- returnTc (binds `AndMonoBinds` prag_binds1 `AndMonoBinds` prag_binds2,
- insts `plusLIE` prag_lie',
- meth)
+ 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 is_inst_decl clas inst_tys sel_id loc (DefMeth dm_name)
+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 is_inst_decl clas inst_tys sel_id loc NoDefMeth
+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 (is_inst_decl && 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 ])
-
-mkDefMethRhs is_inst_decl clas inst_tys sel_id loc GenDefMeth
+ -- 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
-- If the method is defined generically, we can only do the job if the
-- instance declaration is for a single-parameter type class with
-- a type constructor applied to type arguments in the instance decl
-- (checkTc, so False provokes the error)
- checkTc (not is_inst_decl || simple_inst)
- (badGenericInstance sel_id) `thenTc_`
+ ASSERT( isInstDecl origin ) -- We never get here from a class decl
- ioToTc (dumpIfSet opt_PprStyle_Debug "Generic RHS" stuff) `thenNF_Tc_`
- returnTc rhs
+ checkTc (isJust maybe_tycon)
+ (badGenericInstance sel_id (notSimple inst_tys)) `thenM_`
+ checkTc (isJust (tyConGenInfo tycon))
+ (badGenericInstance sel_id (notGeneric tycon)) `thenM_`
+
+ ioToTcRn (dumpIfSet opt_PprStyle_Debug "Generic RHS" stuff) `thenM_`
+ returnM rhs
where
rhs = mkGenericRhs sel_id clas_tyvar tycon
-- case we require that the instance decl is for a single-parameter
-- type class with type variable arguments:
-- instance (...) => C (T a b)
- simple_inst = maybeToBool maybe_tycon
clas_tyvar = head (classTyVars clas)
Just tycon = maybe_tycon
maybe_tycon = case inst_tys of
Just (tycon, arg_tys) | all tcIsTyVarTy arg_tys -> Just tycon
other -> Nothing
other -> Nothing
+
+isInstDecl InstanceDeclOrigin = True
+isInstDecl ClassDeclOrigin = False
\end{code}
Contexts and errors
~~~~~~~~~~~~~~~~~~~
\begin{code}
-nullaryClassErr cls
- = ptext SLIT("No parameters for class") <+> quotes (ppr cls)
-
-classArityErr cls
- = vcat [ptext SLIT("Too many parameters for class") <+> quotes (ppr cls),
- parens (ptext SLIT("Use -fglasgow-exts to allow multi-parameter classes"))]
-
defltMethCtxt clas
= ptext SLIT("When checking the default methods for class") <+> quotes (ppr clas)
omittedMethodWarn sel_id
= ptext SLIT("No explicit method nor default method for") <+> quotes (ppr sel_id)
-badGenericMethodType op op_ty
- = hang (ptext SLIT("Generic method type is too complex"))
- 4 (vcat [ppr op <+> dcolon <+> ppr op_ty,
- ptext SLIT("You can only use type variables, arrows, and tuples")])
-
-badGenericInstance sel_id
+badGenericInstance sel_id because
= sep [ptext SLIT("Can't derive generic code for") <+> quotes (ppr sel_id),
- ptext SLIT("because the instance declaration is not for a simple type (T a b c)"),
- ptext SLIT("(where T is a derivable type constructor)")]
+ because]
+
+notSimple inst_tys
+ = vcat [ptext SLIT("because the instance type(s)"),
+ nest 2 (ppr inst_tys),
+ ptext SLIT("is not a simple type of form (T a b c)")]
+
+notGeneric tycon
+ = vcat [ptext SLIT("because the instance type constructor") <+> quotes (ppr tycon) <+>
+ ptext SLIT("was not compiled with -fgenerics")]
mixedGenericErr op
= ptext SLIT("Can't mix generic and non-generic equations for class method") <+> quotes (ppr op)
-
-genericMultiParamErr clas
- = ptext SLIT("The multi-parameter class") <+> quotes (ppr clas) <+>
- ptext SLIT("cannot have generic methods")
\end{code}
projects / ghc-hetmet.git / blobdiff