\section[TcClassDcl]{Typechecking class declarations}
\begin{code}
-module TcClassDcl ( tcClassDecl1, tcClassDecls2, mkImplicitClassBinds,
+module TcClassDcl ( tcClassDecl1, checkValidClass, tcClassDecls2,
tcMethodBind, badMethodErr
) where
#include "HsVersions.h"
-import HsSyn ( HsDecl(..), TyClDecl(..), Sig(..), MonoBinds(..),
- HsExpr(..), HsLit(..), HsType(..), HsPred(..),
+import HsSyn ( TyClDecl(..), Sig(..), MonoBinds(..),
+ HsExpr(..), HsLit(..),
mkSimpleMatch, andMonoBinds, andMonoBindList,
- isClassDecl, isClassOpSig, isPragSig,
- getClassDeclSysNames, tyClDeclName
+ isClassOpSig, isPragSig,
+ getClassDeclSysNames, placeHolderType
)
-import BasicTypes ( TopLevelFlag(..), RecFlag(..) )
+import BasicTypes ( TopLevelFlag(..), RecFlag(..), StrictnessMark(..) )
import RnHsSyn ( RenamedTyClDecl,
RenamedClassOpSig, RenamedMonoBinds,
- RenamedContext, RenamedHsDecl, RenamedSig,
- maybeGenericMatch
+ RenamedSig, maybeGenericMatch
)
-import TcHsSyn ( TcMonoBinds, idsToMonoBinds )
+import TcHsSyn ( TcMonoBinds )
-import Inst ( InstOrigin(..), LIE, emptyLIE, plusLIE, plusLIEs,
- newDicts, newMethod )
-import TcEnv ( TcId, TcEnv, TyThingDetails(..), tcAddImportedIdInfo,
+import Inst ( Inst, InstOrigin(..), LIE, emptyLIE, plusLIE, plusLIEs,
+ instToId, newDicts, newMethod )
+import TcEnv ( RecTcEnv, TyThingDetails(..), tcAddImportedIdInfo,
tcLookupClass, tcExtendTyVarEnvForMeths, tcExtendGlobalTyVars,
- tcExtendLocalValEnv, tcExtendTyVarEnv, newDefaultMethodName
+ tcExtendLocalValEnv, tcExtendTyVarEnv
)
import TcBinds ( tcBindWithSigs, tcSpecSigs )
-import TcMonoType ( tcHsSigType, tcClassContext, checkSigTyVars, checkAmbiguity, sigCtxt, mkTcSig )
-import TcSimplify ( tcSimplifyAndCheck, bindInstsOfLocalFuns )
-import TcType ( TcType, TcTyVar, tcInstTyVars, zonkTcSigTyVars )
+import TcMonoType ( tcHsType, tcHsTheta, checkSigTyVars, sigCtxt, mkTcSig )
+import TcSimplify ( tcSimplifyCheck, bindInstsOfLocalFuns )
+import TcMType ( tcInstSigTyVars, checkValidTheta, checkValidType, SourceTyCtxt(..), UserTypeCtxt(..) )
+import TcType ( Type, TyVarDetails(..), TcType, TcThetaType, TcTyVar,
+ mkSigmaTy, mkTyVarTys, mkPredTys, mkClassPred,
+ tcIsTyVarTy, tcSplitTyConApp_maybe, tcSplitSigmaTy
+ )
import TcMonad
import Generics ( mkGenericRhs, validGenericMethodType )
import PrelInfo ( nO_METHOD_BINDING_ERROR_ID )
-import Class ( classTyVars, classBigSig, classSelIds, classTyCon, classTvsFds,
- Class, ClassOpItem, DefMeth (..), FunDep )
+import Class ( classTyVars, classBigSig, classTyCon, className,
+ Class, ClassOpItem, DefMeth (..) )
import MkId ( mkDictSelId, mkDataConId, mkDataConWrapId, mkDefaultMethodId )
-import DataCon ( mkDataCon, notMarkedStrict )
-import Id ( Id, idType, idName )
-import Name ( Name, isLocallyDefined, NamedThing(..),
- NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv,
- plusNameEnv, nameEnvElts )
+import DataCon ( mkDataCon )
+import Id ( Id, idType, idName, setIdLocalExported )
+import Module ( Module )
+import Name ( Name, NamedThing(..) )
+import NameEnv ( NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv, plusNameEnv )
import NameSet ( emptyNameSet )
import Outputable
-import Type ( Type, ClassContext, mkTyVarTys, mkDictTys, mkClassPred,
- splitTyConApp_maybe, isTyVarTy
- )
import Var ( TyVar )
import VarSet ( mkVarSet, emptyVarSet )
import CmdLineOpts
import ErrUtils ( dumpIfSet )
-import Util ( count )
-import Maybes ( seqMaybe, maybeToBool, orElse )
+import Util ( count, isSingleton, lengthIs, equalLength )
+import Maybes ( seqMaybe, maybeToBool )
\end{code}
%************************************************************************
\begin{code}
-tcClassDecl1 :: TcEnv -> RenamedTyClDecl -> TcM (Name, TyThingDetails)
-tcClassDecl1 rec_env
- (ClassDecl context class_name
- tyvar_names fundeps class_sigs def_methods
- sys_names src_loc)
- = -- CHECK ARITY 1 FOR HASKELL 1.4
- doptsTc Opt_GlasgowExts `thenTc` \ glaExts ->
- checkTc (glaExts || length tyvar_names == 1)
- (classArityErr class_name) `thenTc_`
- -- LOOK THINGS UP IN THE ENVIRONMENT
+tcClassDecl1 :: RecTcEnv -> RenamedTyClDecl -> TcM (Name, TyThingDetails)
+tcClassDecl1 rec_env
+ (ClassDecl {tcdCtxt = context, tcdName = class_name,
+ tcdTyVars = tyvar_names, tcdFDs = fundeps,
+ tcdSigs = class_sigs, tcdMeths = def_methods,
+ tcdSysNames = sys_names, tcdLoc = src_loc})
+ = -- LOOK THINGS UP IN THE ENVIRONMENT
tcLookupClass class_name `thenTc` \ clas ->
let
- (tyvars, fds) = classTvsFds clas
+ 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
in
tcExtendTyVarEnv tyvars $
- -- CHECK THAT THE DEFAULT BINDINGS ARE LEGAL
- checkDefaultBinds clas op_names def_methods `thenTc` \ dm_info ->
- checkGenericClassIsUnary clas dm_info `thenTc_`
+ checkDefaultBinds clas op_names def_methods `thenTc` \ mb_dm_env ->
-- CHECK THE CONTEXT
- tcSuperClasses clas context sc_sel_names `thenTc` \ (sc_theta, sc_sel_ids) ->
+ -- 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 ->
-- CHECK THE CLASS SIGNATURES,
- mapTc (tcClassSig rec_env clas tyvars fds dm_info)
- op_sigs `thenTc` \ sig_stuff ->
+ mapTc (tcClassSig rec_env clas tyvars mb_dm_env) op_sigs `thenTc` \ sig_stuff ->
-- MAKE THE CLASS DETAILS
let
(op_tys, op_items) = unzip sig_stuff
- sc_tys = mkDictTys sc_theta
+ sc_tys = mkPredTys sc_theta
dict_component_tys = sc_tys ++ op_tys
+ sc_sel_ids = [mkDictSelId sc_name clas | sc_name <- sc_sel_names]
dict_con = mkDataCon datacon_name
- [notMarkedStrict | _ <- dict_component_tys]
+ [NotMarkedStrict | _ <- dict_component_tys]
[{- No labelled fields -}]
tyvars
[{-No context-}]
\end{code}
\begin{code}
-checkDefaultBinds :: Class -> [Name] -> RenamedMonoBinds -> TcM (NameEnv (DefMeth Name))
+checkDefaultBinds :: Class -> [Name] -> Maybe RenamedMonoBinds
+ -> TcM (Maybe (NameEnv Bool))
+ -- The returned environment says
+ -- x not in env => no default method
+ -- x -> True => generic default method
+ -- x -> False => polymorphic default method
+
-- Check default bindings
-- a) must be for a class op for this class
-- b) must be all generic or all non-generic
-- and return a mapping from class-op to DefMeth info
-checkDefaultBinds clas ops EmptyMonoBinds = returnTc emptyNameEnv
+ -- But do all this only for source binds
+
+checkDefaultBinds clas ops Nothing
+ = returnTc Nothing
+
+checkDefaultBinds clas ops (Just mbs)
+ = go mbs `thenTc` \ dm_env ->
+ returnTc (Just dm_env)
+ where
+ go EmptyMonoBinds = returnTc emptyNameEnv
-checkDefaultBinds clas ops (AndMonoBinds b1 b2)
- = checkDefaultBinds clas ops b1 `thenTc` \ dm_info1 ->
- checkDefaultBinds clas ops b2 `thenTc` \ dm_info2 ->
- returnTc (dm_info1 `plusNameEnv` dm_info2)
+ go (AndMonoBinds b1 b2)
+ = go b1 `thenTc` \ dm_info1 ->
+ go b2 `thenTc` \ dm_info2 ->
+ returnTc (dm_info1 `plusNameEnv` dm_info2)
-checkDefaultBinds clas ops (FunMonoBind op _ matches loc)
- = tcAddSrcLoc loc $
+ go (FunMonoBind op _ matches loc)
+ = tcAddSrcLoc loc $
-- Check that the op is from this class
- checkTc (op `elem` ops) (badMethodErr clas op) `thenTc_`
+ checkTc (op `elem` ops) (badMethodErr clas op) `thenTc_`
-- 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) `thenTc_`
- -- Make up the right dm_info
- if all_generic then
- returnTc (unitNameEnv op GenDefMeth)
- else
- -- An explicit non-generic default method
- newDefaultMethodName op loc `thenNF_Tc` \ dm_name ->
- returnTc (unitNameEnv op (DefMeth dm_name))
-
- where
- n_generic = count (maybeToBool . maybeGenericMatch) matches
- none_generic = n_generic == 0
- all_generic = n_generic == length matches
-
-checkGenericClassIsUnary clas dm_info
- = -- 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 clas)
- where
- unary = length (classTyVars clas) == 1
- no_generics = null [() | GenDefMeth <- nameEnvElts dm_info]
+ returnTc (unitNameEnv op all_generic)
+ where
+ n_generic = count (maybeToBool . maybeGenericMatch) matches
+ none_generic = n_generic == 0
+ all_generic = matches `lengthIs` n_generic
\end{code}
\begin{code}
-tcSuperClasses :: Class
- -> RenamedContext -- class context
- -> [Name] -- Names for superclass selectors
- -> TcM (ClassContext, -- the superclass context
- [Id]) -- superclass selector Ids
-
-tcSuperClasses clas context sc_sel_names
- = -- Check the context.
- -- The renamer has already checked that the context mentions
- -- only the type variable of the class decl.
-
- -- For std Haskell check that the context constrains only tyvars
- doptsTc Opt_GlasgowExts `thenTc` \ glaExts ->
- (if glaExts then
- returnTc ()
- else
- mapTc_ check_constraint context
- ) `thenTc_`
-
- -- Context is already kind-checked
- tcClassContext context `thenTc` \ sc_theta ->
- let
- sc_sel_ids = [mkDictSelId sc_name clas | sc_name <- sc_sel_names]
- in
- -- Done
- returnTc (sc_theta, sc_sel_ids)
-
- where
- check_constraint sc@(HsPClass c tys)
- = checkTc (all is_tyvar tys) (superClassErr clas sc)
-
- is_tyvar (HsTyVar _) = True
- is_tyvar other = False
-
-
-tcClassSig :: TcEnv -- Knot tying only!
+tcClassSig :: RecTcEnv -- Knot tying only!
-> Class -- ...ditto...
-> [TyVar] -- The class type variable, used for error check only
- -> [FunDep TyVar]
- -> NameEnv (DefMeth Name) -- Info about default methods
+ -> Maybe (NameEnv Bool) -- Info about default methods;
+ -- Nothing => imported class defn with no method binds
-> RenamedClassOpSig
-> TcM (Type, -- Type of the method
ClassOpItem) -- Selector Id, default-method Id, True if explicit default binding
-- so we distinguish them in checkDefaultBinds, and pass this knowledge in the
-- Class.DefMeth data structure.
-tcClassSig rec_env clas clas_tyvars fds dm_info
- (ClassOpSig op_name maybe_dm op_ty src_loc)
+tcClassSig unf_env clas clas_tyvars maybe_dm_env
+ (ClassOpSig op_name sig_dm op_ty src_loc)
= tcAddSrcLoc 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 ->
- tcHsSigType op_ty `thenTc` \ local_ty ->
let
theta = [mkClassPred clas (mkTyVarTys clas_tyvars)]
- in
- -- Check for ambiguous class op types
- checkAmbiguity True clas_tyvars theta local_ty `thenTc` \ global_ty ->
- let
-- Build the selector id and default method id
- sel_id = mkDictSelId op_name clas
+ sel_id = mkDictSelId op_name clas
+ DefMeth dm_name = sig_dm
- dm_info_name = maybe_dm `orElse` lookupNameEnv dm_info op_name `orElse` NoDefMeth
+ dm_info = case maybe_dm_env of
+ Nothing -> sig_dm
+ Just dm_env -> mk_src_dm_info dm_env
- dm_info_id = case dm_info_name of
- NoDefMeth -> NoDefMeth
- GenDefMeth -> GenDefMeth
- DefMeth dm_name -> DefMeth (tcAddImportedIdInfo rec_env dm_id)
- where
- dm_id = mkDefaultMethodId dm_name clas global_ty
+ mk_src_dm_info dm_env = case lookupNameEnv dm_env op_name of
+ Nothing -> NoDefMeth
+ Just True -> GenDefMeth
+ Just False -> DefMeth dm_name
in
- -- Check that for a generic method, the type of
- -- the method is sufficiently simple
- checkTc (dm_info_name /= GenDefMeth || validGenericMethodType local_ty)
- (badGenericMethodType op_name op_ty) `thenTc_`
-
- returnTc (local_ty, (sel_id, dm_info_id))
+ 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.
-%************************************************************************
-%* *
-\subsection[ClassDcl-pass2]{Class decls pass 2: default methods}
-%* *
-%************************************************************************
+\begin{code}
+checkValidClass :: Class -> TcM ()
+checkValidClass cls
+ = -- CHECK ARITY 1 FOR HASKELL 1.4
+ doptsTc Opt_GlasgowExts `thenTc` \ gla_exts ->
-@mkImplicitClassBinds@ produces a binding for the selector function for each method
-and superclass dictionary.
+ -- Check that the class is unary, unless GlaExs
+ checkTc (not (null tyvars)) (nullaryClassErr cls) `thenTc_`
+ checkTc (gla_exts || unary) (classArityErr cls) `thenTc_`
-\begin{code}
-mkImplicitClassBinds :: [Class] -> NF_TcM ([Id], TcMonoBinds)
-mkImplicitClassBinds classes
- = returnNF_Tc (concat cls_ids_s, andMonoBindList binds_s)
- -- The selector binds are already in the selector Id's unfoldings
- -- We don't return the data constructor etc from the class,
- -- because that's done via the class's TyCon
- where
- (cls_ids_s, binds_s) = unzip (map mk_implicit classes)
+ -- Check the super-classes
+ checkValidTheta (ClassSCCtxt (className cls)) theta `thenTc_`
- mk_implicit clas = (sel_ids, binds)
- where
- sel_ids = classSelIds clas
- binds | isLocallyDefined clas = idsToMonoBinds sel_ids
- | otherwise = EmptyMonoBinds
-\end{code}
+ -- 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
+\end{code}
%************************************************************************
each local class decl.
\begin{code}
-tcClassDecls2 :: [RenamedHsDecl] -> NF_TcM (LIE, TcMonoBinds)
+tcClassDecls2 :: Module -> [RenamedTyClDecl] -> NF_TcM (LIE, TcMonoBinds, [Id])
-tcClassDecls2 decls
+tcClassDecls2 this_mod decls
= foldr combine
- (returnNF_Tc (emptyLIE, EmptyMonoBinds))
- [tcClassDecl2 cls_decl | TyClD cls_decl <- decls,
- isClassDecl cls_decl,
- isLocallyDefined (tyClDeclName cls_decl)]
+ (returnNF_Tc (emptyLIE, 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) ->
- tc2 `thenNF_Tc` \ (lie2, binds2) ->
+ combine tc1 tc2 = tc1 `thenNF_Tc` \ (lie1, binds1, ids1) ->
+ tc2 `thenNF_Tc` \ (lie2, binds2, ids2) ->
returnNF_Tc (lie1 `plusLIE` lie2,
- binds1 `AndMonoBinds` binds2)
+ 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)
+ -> NF_TcM (LIE, TcMonoBinds, [Id])
-tcClassDecl2 (ClassDecl context class_name
- tyvar_names _ sigs default_binds _ src_loc)
- = -- A locally defined class
- recoverNF_Tc (returnNF_Tc (emptyLIE, EmptyMonoBinds)) $
+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 ->
prags = filter isPragSig sigs
tc_dm = tcDefMeth clas tyvars default_binds prags
in
- mapAndUnzipTc tc_dm op_items `thenTc` \ (defm_binds, const_lies) ->
+ mapAndUnzip3Tc tc_dm op_items `thenTc` \ (defm_binds, const_lies, dm_ids_s) ->
- returnTc (plusLIEs const_lies, andMonoBindList defm_binds)
+ returnTc (plusLIEs const_lies, 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) = returnTc (EmptyMonoBinds, emptyLIE, [])
+tcDefMeth clas tyvars binds_in prags (_, GenDefMeth) = returnTc (EmptyMonoBinds, emptyLIE, [])
-- 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
-- the programmer supplied an explicit default decl for the class.
-- (If necessary we can fix that, but we don't have a convenient Id to hand.)
-tcDefMeth clas tyvars binds_in prags op_item@(_, DefMeth dm_id)
- = tcInstTyVars tyvars `thenNF_Tc` \ (clas_tyvars, inst_tys, _) ->
+tcDefMeth clas tyvars binds_in prags op_item@(sel_id, DefMeth dm_name)
+ = tcInstSigTyVars ClsTv tyvars `thenNF_Tc` \ clas_tyvars ->
let
- theta = [(mkClassPred clas inst_tys)]
+ dm_ty = idType sel_id -- Same as dict selector!
+ -- The default method's type should really come from the
+ -- iface file, since it could be usage-generalised, but this
+ -- requires altering the mess of knots in TcModule and I'm
+ -- too scared to do that. Instead, I have disabled generalisation
+ -- 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
in
- newDicts origin theta `thenNF_Tc` \ (this_dict, [this_dict_id]) ->
+ newDicts origin theta `thenNF_Tc` \ [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_id)) ->
+ ) `thenTc` \ (defm_bind, insts_needed, local_dm_inst) ->
tcAddErrCtxt (defltMethCtxt clas) $
- -- tcMethodBind has checked that the class_tyvars havn't
- -- been unified with each other or another type, but we must
- -- still zonk them before passing them to tcSimplifyAndCheck
- zonkTcSigTyVars clas_tyvars `thenNF_Tc` \ clas_tyvars' ->
-
-- Check the context
- tcSimplifyAndCheck
+ tcSimplifyCheck
(ptext SLIT("class") <+> ppr clas)
- (mkVarSet clas_tyvars')
- this_dict
- insts_needed `thenTc` \ (const_lie, dict_binds) ->
+ clas_tyvars
+ [this_dict]
+ insts_needed `thenTc` \ (const_lie, dict_binds) ->
+
+ -- Simplification can do unification
+ checkSigTyVars clas_tyvars emptyVarSet `thenTc` \ clas_tyvars' ->
let
full_bind = AbsBinds
clas_tyvars'
- [this_dict_id]
- [(clas_tyvars', dm_id, local_dm_id)]
+ [instToId this_dict]
+ [(clas_tyvars', local_dm_id, instToId local_dm_inst)]
emptyNameSet -- No inlines (yet)
(dict_binds `andMonoBinds` defm_bind)
in
- returnTc (full_bind, const_lie)
+ returnTc (full_bind, const_lie, [dm_id])
where
origin = ClassDeclOrigin
\end{code}
-> [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, (LIE, TcId))
+ -> 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@(_, meth_id) ->
- mkTcSig meth_id loc `thenNF_Tc` \ sig_info ->
+ newMethod origin sel_id inst_tys `thenNF_Tc` \ meth ->
let
+ meth_id = instToId meth
meth_name = idName meth_id
sig_msg = ptext SLIT("When checking the expected type for class method") <+> ppr sel_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
(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 Nothing loc] loc)
+ [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
tcExtendGlobalTyVars (mkVarSet inst_tyvars)
(tcAddErrCtxt (methodCtxt sel_id) $
tcBindWithSigs NotTopLevel meth_bind
- [sig_info] meth_prags NonRecursive
+ [sig_info] meth_prags NonRecursive
) `thenTc` \ (binds, insts, _) ->
tcExtendLocalValEnv [(meth_name, 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_id)
+mkDefMethRhs is_inst_decl clas inst_tys sel_id loc (DefMeth dm_name)
= -- An polymorphic default method
- returnTc (HsVar (idName dm_id))
+ returnTc (HsVar dm_name)
mkDefMethRhs is_inst_decl clas inst_tys sel_id loc NoDefMeth
= -- No default method
-- Warn only if -fwarn-missing-methods
- doptsTc Opt_WarnMissingMethods `thenNF_Tc` \ warn ->
+ doptsTc Opt_WarnMissingMethods `thenNF_Tc` \ warn ->
warnTc (is_inst_decl && warn)
- (omittedMethodWarn sel_id clas) `thenNF_Tc_`
+ (omittedMethodWarn sel_id) `thenNF_Tc_`
returnTc error_rhs
where
error_rhs = HsApp (HsVar (getName nO_METHOD_BINDING_ERROR_ID))
-- 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 clas) `thenTc_`
+ (badGenericInstance sel_id) `thenTc_`
ioToTc (dumpIfSet opt_PprStyle_Debug "Generic RHS" stuff) `thenNF_Tc_`
returnTc rhs
clas_tyvar = head (classTyVars clas)
Just tycon = maybe_tycon
maybe_tycon = case inst_tys of
- [ty] -> case splitTyConApp_maybe ty of
- Just (tycon, arg_tys) | all isTyVarTy arg_tys -> Just tycon
- other -> Nothing
+ [ty] -> case tcSplitTyConApp_maybe ty of
+ Just (tycon, arg_tys) | all tcIsTyVarTy arg_tys -> Just tycon
+ other -> Nothing
other -> Nothing
\end{code}
find_prags sel_name meth_name [] = []
find_prags sel_name meth_name (SpecSig name ty loc : prags)
| name == sel_name = SpecSig meth_name ty loc : find_prags sel_name meth_name prags
-find_prags sel_name meth_name (InlineSig name phase loc : prags)
- | name == sel_name = InlineSig meth_name phase loc : find_prags sel_name meth_name prags
-find_prags sel_name meth_name (NoInlineSig name phase loc : prags)
- | name == sel_name = NoInlineSig meth_name phase loc : find_prags sel_name meth_name prags
+find_prags sel_name meth_name (InlineSig sense name phase loc : prags)
+ | name == sel_name = InlineSig sense meth_name phase loc : find_prags sel_name meth_name prags
find_prags sel_name meth_name (prag:prags) = find_prags sel_name meth_name prags
\end{code}
Contexts and errors
~~~~~~~~~~~~~~~~~~~
\begin{code}
-classArityErr class_name
- = ptext SLIT("Too many parameters for class") <+> quotes (ppr class_name)
+nullaryClassErr cls
+ = ptext SLIT("No parameters for class") <+> quotes (ppr cls)
-superClassErr clas sc
- = ptext SLIT("Illegal superclass constraint") <+> quotes (ppr sc)
- <+> ptext SLIT("in declaration for class") <+> quotes (ppr clas)
+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)
= hsep [ptext SLIT("Class"), quotes (ppr clas),
ptext SLIT("does not have a method"), quotes (ppr op)]
-omittedMethodWarn sel_id clas
- = sep [ptext SLIT("No explicit method nor default method for") <+> quotes (ppr sel_id),
- ptext SLIT("in an instance declaration for") <+> 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 clas
+badGenericInstance sel_id
= 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)"),
- ptext SLIT("in an instance declaration for") <+> quotes (ppr clas)]
+ ptext SLIT("(where T is a derivable type constructor)")]
mixedGenericErr op
= ptext SLIT("Can't mix generic and non-generic equations for class method") <+> quotes (ppr op)