\section[TcClassDcl]{Typechecking class declarations}
\begin{code}
-module TcClassDcl ( tcClassDecl1, tcClassDecls2, mkImplicitClassBinds,
+module TcClassDcl ( tcClassDecl1, tcClassDecls2,
tcMethodBind, badMethodErr
) where
#include "HsVersions.h"
-import HsSyn ( HsDecl(..), TyClDecl(..), Sig(..), MonoBinds(..),
- HsExpr(..), HsLit(..), HsType(..), HsPred(..),
+import HsSyn ( TyClDecl(..), Sig(..), MonoBinds(..),
+ HsExpr(..), HsLit(..), HsType(..), HsPred(..),
mkSimpleMatch, andMonoBinds, andMonoBindList,
- isClassDecl, isClassOpSig, isPragSig,
- getClassDeclSysNames, tyClDeclName
+ isClassOpSig, isPragSig,
+ getClassDeclSysNames,
)
import BasicTypes ( TopLevelFlag(..), RecFlag(..) )
import RnHsSyn ( RenamedTyClDecl,
RenamedClassOpSig, RenamedMonoBinds,
- RenamedContext, RenamedHsDecl, RenamedSig,
+ RenamedContext, 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 TcEnv ( TcId, 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 TcMonoType ( tcHsRecType, tcRecClassContext, checkSigTyVars, checkAmbiguity, sigCtxt, mkTcSig )
import TcSimplify ( tcSimplifyAndCheck, bindInstsOfLocalFuns )
import TcType ( TcType, TcTyVar, tcInstTyVars, zonkTcSigTyVars )
import TcMonad
import Generics ( mkGenericRhs, validGenericMethodType )
import PrelInfo ( nO_METHOD_BINDING_ERROR_ID )
-import Class ( classTyVars, classBigSig, classSelIds, classTyCon,
+import Class ( classTyVars, classBigSig, classTyCon,
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 Module ( Module )
+import Name ( Name, NamedThing(..) )
+import Name ( NameEnv, lookupNameEnv, emptyNameEnv, unitNameEnv, plusNameEnv, nameEnvElts )
import NameSet ( emptyNameSet )
import Outputable
-import Type ( Type, ClassContext, mkTyVarTys, mkDictTys, mkSigmaTy, mkClassPred,
+import Type ( Type, ClassContext, mkTyVarTys, mkDictTys, mkClassPred,
splitTyConApp_maybe, isTyVarTy
)
import Var ( TyVar )
import CmdLineOpts
import ErrUtils ( dumpIfSet )
import Util ( count )
-import Maybes ( seqMaybe, maybeToBool, orElse )
+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)
+
+tcClassDecl1 :: RecFlag -> RecTcEnv -> RenamedTyClDecl -> TcM (Name, TyThingDetails)
+tcClassDecl1 is_rec 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})
= -- CHECK ARITY 1 FOR HASKELL 1.4
- doptsTc Opt_GlasgowExts `thenTc` \ glaExts ->
- checkTc (glaExts || length tyvar_names == 1)
+ doptsTc Opt_GlasgowExts `thenTc` \ gla_ext_opt ->
+ let
+ gla_exts = gla_ext_opt || not (maybeToBool def_methods)
+ -- Accept extensions if gla_exts is on,
+ -- or if we're looking at an interface file decl
+ in -- (in which case def_methods = Nothing
+
+ checkTc (gla_exts || length tyvar_names == 1)
(classArityErr class_name) `thenTc_`
-- 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_`
+ -- SOURCE-CODE CONSISTENCY CHECKS
+ (case def_methods of
+ Nothing -> returnTc Nothing -- Not source
+ Just dms -> checkDefaultBinds clas op_names dms `thenTc` \ dm_env ->
+ checkGenericClassIsUnary clas dm_env `thenTc_`
+ returnTc (Just dm_env)
+ ) `thenTc` \ mb_dm_env ->
-- CHECK THE CONTEXT
- tcSuperClasses clas context sc_sel_names `thenTc` \ (sc_theta, sc_sel_ids) ->
+ tcSuperClasses is_rec gla_exts clas context sc_sel_names `thenTc` \ (sc_theta, sc_sel_ids) ->
-- CHECK THE CLASS SIGNATURES,
- mapTc (tcClassSig rec_env tyvar_names clas tyvars fds dm_info)
- op_sigs `thenTc` \ sig_stuff ->
+ mapTc (tcClassSig is_rec rec_env clas tyvars mb_dm_env) op_sigs `thenTc` \ sig_stuff ->
-- MAKE THE CLASS DETAILS
let
\end{code}
\begin{code}
-checkDefaultBinds :: Class -> [Name] -> RenamedMonoBinds -> TcM (NameEnv (DefMeth Name))
+checkDefaultBinds :: Class -> [Name] -> RenamedMonoBinds
+ -> TcM (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
+ -- But do all this only for source binds
+
checkDefaultBinds clas ops EmptyMonoBinds = returnTc emptyNameEnv
checkDefaultBinds clas ops (AndMonoBinds b1 b2)
-- Check that all the defns ar generic, or none are
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))
-
+ returnTc (unitNameEnv op all_generic)
where
n_generic = count (maybeToBool . maybeGenericMatch) matches
none_generic = n_generic == 0
all_generic = n_generic == length matches
-checkGenericClassIsUnary clas dm_info
+checkGenericClassIsUnary clas dm_env
= -- 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]
+ no_generics = not (or (nameEnvElts dm_env))
\end{code}
\begin{code}
-tcSuperClasses :: Class
+tcSuperClasses :: RecFlag -> Bool -> Class
-> RenamedContext -- class context
-> [Name] -- Names for superclass selectors
-> TcM (ClassContext, -- the superclass context
[Id]) -- superclass selector Ids
-tcSuperClasses clas context sc_sel_names
+tcSuperClasses is_rec gla_exts 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
+ (if gla_exts then
returnTc ()
else
mapTc_ check_constraint context
) `thenTc_`
-- Context is already kind-checked
- tcClassContext context `thenTc` \ sc_theta ->
+ tcRecClassContext is_rec context `thenTc` \ sc_theta ->
let
sc_sel_ids = [mkDictSelId sc_name clas | sc_name <- sc_sel_names]
in
is_tyvar other = False
-tcClassSig :: TcEnv -- Knot tying only!
- -> [HsTyVarBndr Name] -- From the declaration, for error messages
+tcClassSig :: RecFlag -> 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
-> 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 tyvar_names clas clas_tyvars fds dm_info
- (ClassOpSig op_name maybe_dm op_ty src_loc)
+tcClassSig is_rec 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.
- tcHsSigType op_ty `thenTc` \ local_ty ->
+ tcHsRecType is_rec op_ty `thenTc` \ local_ty ->
+
+ -- Check for ambiguous class op types
let
- theta = [mkClassPred clas (mkTyVarTys clas_tyvars)]
- global_ty = mkSigmaTy clas_tyvars theta local_ty
+ theta = [mkClassPred clas (mkTyVarTys clas_tyvars)]
+ in
+ checkAmbiguity is_rec True clas_tyvars theta local_ty `thenTc` \ global_ty ->
+ -- 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.
+ let
-- Build the selector id and default method id
- sel_id = mkDictSelId op_name clas
-
- dm_info_name = maybe_dm `orElse` lookupNameEnv dm_info op_name `orElse` NoDefMeth
-
- 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
-
- full_hs_ty = HsForAllTy (Just tyvar_names) op_ty
+ sel_id = mkDictSelId op_name clas
+ dm_id = mkDefaultMethodId dm_name clas global_ty
+ DefMeth dm_name = sig_dm
+
+ dm_info = case maybe_dm_env of
+ Nothing -> iface_dm_info
+ Just dm_env -> mk_src_dm_info dm_env
+
+ iface_dm_info = case sig_dm of
+ NoDefMeth -> NoDefMeth
+ GenDefMeth -> GenDefMeth
+ DefMeth dm_name -> DefMeth (tcAddImportedIdInfo unf_env dm_id)
+
+ mk_src_dm_info dm_env = case lookupNameEnv dm_env op_name of
+ Nothing -> NoDefMeth
+ Just True -> GenDefMeth
+ Just False -> DefMeth dm_id
in
- -- Check for ambiguous class op types
- checkAmbiguity full_ty clas_tyvars theta local_ty `thenRn_`
-
-- Check that for a generic method, the type of
-- the method is sufficiently simple
- checkTc (dm_info_name /= GenDefMeth || validGenericMethodType local_ty)
+ checkTc (dm_info /= GenDefMeth || validGenericMethodType local_ty)
(badGenericMethodType op_name op_ty) `thenTc_`
- returnTc (local_ty, (sel_id, dm_info_id))
-\end{code}
-
-
-%************************************************************************
-%* *
-\subsection[ClassDcl-pass2]{Class decls pass 2: default methods}
-%* *
-%************************************************************************
-
-@mkImplicitClassBinds@ produces a binding for the selector function for each method
-and superclass dictionary.
-
-\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)
-
- mk_implicit clas = (sel_ids, binds)
- where
- sel_ids = classSelIds clas
- binds | isLocallyDefined clas = idsToMonoBinds sel_ids
- | otherwise = EmptyMonoBinds
+ returnTc (local_ty, (sel_id, dm_info))
\end{code}
-
%************************************************************************
%* *
\subsection[Default methods]{Default methods}
each local class decl.
\begin{code}
-tcClassDecls2 :: [RenamedHsDecl] -> NF_TcM (LIE, TcMonoBinds)
+tcClassDecls2 :: Module -> [RenamedTyClDecl] -> NF_TcM (LIE, TcMonoBinds)
-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)]
+ [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) ->
tcClassDecl2 :: RenamedTyClDecl -- The class declaration
-> NF_TcM (LIE, TcMonoBinds)
-tcClassDecl2 (ClassDecl context class_name
- tyvar_names _ sigs default_binds _ src_loc)
- = -- A locally defined class
+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 ->
projects / ghc-hetmet.git / blobdiff