-@processInstBinds@ returns a @MonoBinds@ which binds
-all the method ids (which are passed in). It is used
- - both for instance decls,
- - and to compile the default-method declarations in a class decl.
-
-Any method ids which don't have a binding have a suitable default
-binding created for them. The actual right-hand side used is
-created using a function which is passed in, because the right thing to
-do differs between instance and class decls.
-
-\begin{code}
-processInstBinds
- :: (Int -> NF_TcM s (TcExpr s)) -- Function to make default method
- -> [TcTyVar s] -- Tyvars for this instance decl
- -> LIE s -- available Insts
- -> [TcIdOcc s] -- Local method ids in tag order
- -- (instance tyvars are free in their types)
- -> RenamedMonoBinds
- -> TcM s (LIE s, -- These are required
- TcMonoBinds s)
-
-processInstBinds mk_default_method_rhs inst_tyvars avail_insts method_ids monobinds
- =
- -- Process the explicitly-given method bindings
- processInstBinds1 inst_tyvars avail_insts method_ids monobinds
- `thenTc` \ (tags, insts_needed_in_methods, method_binds) ->
-
- -- Find the methods not handled, and make default method bindings for them.
- let
- unmentioned_tags = [1.. length method_ids] `minusList` tags
- in
- mapNF_Tc mk_default_method unmentioned_tags
- `thenNF_Tc` \ default_bind_list ->
-
- returnTc (insts_needed_in_methods,
- foldr AndMonoBinds method_binds default_bind_list)
- where
- -- From a tag construct us the passed-in function to construct
- -- the binding for the default method
- mk_default_method tag = mk_default_method_rhs tag `thenNF_Tc` \ rhs ->
- returnNF_Tc (VarMonoBind (method_ids !! (tag-1)) rhs)
-\end{code}
-
-\begin{code}
-processInstBinds1
- :: [TcTyVar s] -- Tyvars for this instance decl
- -> LIE s -- available Insts
- -> [TcIdOcc s] -- Local method ids in tag order (instance tyvars are free),
- -> RenamedMonoBinds
- -> TcM s ([Int], -- Class-op tags accounted for
- LIE s, -- These are required
- TcMonoBinds s)
-
-processInstBinds1 inst_tyvars avail_insts method_ids EmptyMonoBinds
- = returnTc ([], emptyLIE, EmptyMonoBinds)
-
-processInstBinds1 inst_tyvars avail_insts method_ids (AndMonoBinds mb1 mb2)
- = processInstBinds1 inst_tyvars avail_insts method_ids mb1
- `thenTc` \ (op_tags1,dicts1,method_binds1) ->
- processInstBinds1 inst_tyvars avail_insts method_ids mb2
- `thenTc` \ (op_tags2,dicts2,method_binds2) ->
- returnTc (op_tags1 ++ op_tags2,
- dicts1 `unionBags` dicts2,
- AndMonoBinds method_binds1 method_binds2)
-\end{code}
-
-\begin{code}
-processInstBinds1 inst_tyvars avail_insts method_ids mbind
- =
- -- Find what class op is being defined here. The complication is
- -- that we could have a PatMonoBind or a FunMonoBind. If the
- -- former, it should only bind a single variable, or else we're in
- -- trouble (I'm not sure what the static semantics of methods
- -- defined in a pattern binding with multiple patterns is!)
- -- Renamer has reduced us to these two cases.
- let
- (op,locn) = case mbind of
- FunMonoBind op _ locn -> (op, locn)
- PatMonoBind (VarPatIn op) _ locn -> (op, locn)
-
- occ = getLocalName op
- origin = InstanceDeclOrigin
- in
- tcAddSrcLoc locn $
-
- -- Make a method id for the method
- let tag = panic "processInstBinds1:getTagFromClassOpName"{-getTagFromClassOpName op-}
- method_id = method_ids !! (tag-1)
-
- method_ty = tcIdType method_id
- (method_tyvars, method_theta, method_tau) = splitSigmaTy method_ty
- in
- newDicts origin method_theta `thenNF_Tc` \ (method_dicts,method_dict_ids) ->
-
- case (method_tyvars, method_dict_ids) of
-
- ([],[]) -> -- The simple case; no local polymorphism or overloading in the method
-
- -- Type check the method itself
- tcMethodBind method_id method_tau mbind `thenTc` \ (mbind', lieIop) ->
- returnTc ([tag], lieIop, mbind')
-
- other -> -- It's a locally-polymorphic and/or overloaded method; UGH!
-
- -- Make a new id for (a) the local, non-overloaded method
- -- and (b) the locally-overloaded method
- -- The latter is needed just so we can return an AbsBinds wrapped
- -- up inside a MonoBinds.
-
- newLocalId occ method_tau `thenNF_Tc` \ local_id ->
- newLocalId occ method_ty `thenNF_Tc` \ copy_id ->
- let
- inst_method_tyvars = inst_tyvars ++ method_tyvars
- in
- -- Typecheck the method
- tcMethodBind local_id method_tau mbind `thenTc` \ (mbind', lieIop) ->
-
- -- Check the overloading part of the signature.
- -- Simplify everything fully, even though some
- -- constraints could "really" be left to the next
- -- level out. The case which forces this is
- --
- -- class Foo a where { op :: Bar a => a -> a }
- --
- -- Here we must simplify constraints on "a" to catch all
- -- the Bar-ish things.
- tcAddErrCtxt (methodSigCtxt op method_ty) (
- tcSimplifyAndCheck
- (mkTyVarSet inst_method_tyvars)
- (method_dicts `plusLIE` avail_insts)
- lieIop
- ) `thenTc` \ (f_dicts, dict_binds) ->
-
- returnTc ([tag],
- f_dicts,
- VarMonoBind method_id
- (HsLet
- (AbsBinds
- method_tyvars
- method_dict_ids
- [(local_id, copy_id)]
- dict_binds
- (NonRecBind mbind'))
- (HsVar copy_id)))
-\end{code}
-
-\begin{code}
-tcMethodBind :: TcIdOcc s -> TcType s -> RenamedMonoBinds
- -> TcM s (TcMonoBinds s, LIE s)
-
-tcMethodBind meth_id meth_ty (FunMonoBind name matches locn)
- = tcMatchesFun name meth_ty matches `thenTc` \ (rhs', lie) ->
- returnTc (FunMonoBind meth_id rhs' locn, lie)
-
-tcMethodBind meth_id meth_ty pbind@(PatMonoBind pat grhss_and_binds locn)
- -- pat is sure to be a (VarPatIn op)
- = tcAddErrCtxt (patMonoBindsCtxt pbind) $
- tcGRHSsAndBinds grhss_and_binds `thenTc` \ (grhss_and_binds', lie, rhs_ty) ->
- unifyTauTy meth_ty rhs_ty `thenTc_`
- returnTc (PatMonoBind (VarPat meth_id) grhss_and_binds' locn, lie)
-\end{code}
-
-
-%************************************************************************
-%* *
-\subsection{Type-checking specialise instance pragmas}
-%* *
-%************************************************************************
-
-\begin{code}
-{- LATER
-tcSpecInstSigs :: E -> CE -> TCE
- -> Bag InstInfo -- inst decls seen (declared and derived)
- -> [RenamedSpecInstSig] -- specialise instance upragmas
- -> TcM (Bag InstInfo) -- new, overlapped, inst decls
-
-tcSpecInstSigs e ce tce inst_infos []
- = returnTc emptyBag
-
-tcSpecInstSigs e ce tce inst_infos sigs
- = buildInstanceEnvs inst_infos `thenTc` \ inst_mapper ->
- tc_inst_spec_sigs inst_mapper sigs `thenNF_Tc` \ spec_inst_infos ->
- returnTc spec_inst_infos
- where
- tc_inst_spec_sigs inst_mapper []
- = returnNF_Tc emptyBag
- tc_inst_spec_sigs inst_mapper (sig:sigs)
- = tcSpecInstSig e ce tce inst_infos inst_mapper sig `thenNF_Tc` \ info_sig ->
- tc_inst_spec_sigs inst_mapper sigs `thenNF_Tc` \ info_sigs ->
- returnNF_Tc (info_sig `unionBags` info_sigs)
-
-tcSpecInstSig :: E -> CE -> TCE
- -> Bag InstInfo
- -> InstanceMapper
- -> RenamedSpecInstSig
- -> NF_TcM (Bag InstInfo)
-
-tcSpecInstSig e ce tce inst_infos inst_mapper (SpecInstSig class_name ty src_loc)
- = recoverTc emptyBag (
- tcAddSrcLoc src_loc (
- let
- clas = lookupCE ce class_name -- Renamer ensures this can't fail
-
- -- Make some new type variables, named as in the specialised instance type
- ty_names = extractMonoTyNames (==) ty
- (tmpl_e,inst_tmpls,inst_tmpl_tys) = mkTVE ty_names
- in
- babyTcMtoTcM (tcInstanceType ce tce tmpl_e True src_loc ty)
- `thenTc` \ inst_ty ->
- let
- maybe_tycon = case maybeAppDataTyCon inst_ty of
- Just (tc,_,_) -> Just tc
- Nothing -> Nothing
-
- maybe_unspec_inst = lookup_unspec_inst clas maybe_tycon inst_infos
- in
- -- Check that we have a local instance declaration to specialise
- checkMaybeTc maybe_unspec_inst
- (specInstUnspecInstNotFoundErr clas inst_ty src_loc) `thenTc_`
-
- -- Create tvs to substitute for tmpls while simplifying the context
- copyTyVars inst_tmpls `thenNF_Tc` \ (tv_e, inst_tvs, inst_tv_tys) ->
- let
- Just (InstInfo _ unspec_tyvars unspec_inst_ty unspec_theta
- _ _ _ binds True{-from here-} mod _ uprag) = maybe_unspec_inst
-
- subst = case matchTy unspec_inst_ty inst_ty of
- Just subst -> subst
- Nothing -> panic "tcSpecInstSig:matchTy"
-
- subst_theta = instantiateThetaTy subst unspec_theta
- subst_tv_theta = instantiateThetaTy tv_e subst_theta
-
- mk_spec_origin clas ty
- = InstanceSpecOrigin inst_mapper clas ty src_loc
- in
- tcSimplifyThetas mk_spec_origin subst_tv_theta
- `thenTc` \ simpl_tv_theta ->
- let
- simpl_theta = [ (clas, tv_to_tmpl tv) | (clas, tv) <- simpl_tv_theta ]
-
- tv_tmpl_map = inst_tv_tys `zipEqual` inst_tmpl_tys
- tv_to_tmpl tv = assoc "tcSpecInstSig" tv_tmpl_map tv
- in
- mkInstanceRelatedIds e True{-from here-} mod NoInstancePragmas src_loc
- clas inst_tmpls inst_ty simpl_theta uprag
- `thenTc` \ (dfun_id, dfun_theta, const_meth_ids) ->
-
- getSwitchCheckerTc `thenNF_Tc` \ sw_chkr ->
- (if sw_chkr SpecialiseTrace then
- pprTrace "Specialised Instance: "
- (ppAboves [ppCat [if null simpl_theta then ppNil else ppr PprDebug simpl_theta,
- if null simpl_theta then ppNil else ppStr "=>",
- ppr PprDebug clas,
- pprParendGenType PprDebug inst_ty],
- ppCat [ppStr " derived from:",
- if null unspec_theta then ppNil else ppr PprDebug unspec_theta,
- if null unspec_theta then ppNil else ppStr "=>",
- ppr PprDebug clas,
- pprParendGenType PprDebug unspec_inst_ty]])
- else id) (
-
- returnTc (unitBag (InstInfo clas inst_tmpls inst_ty simpl_theta
- dfun_theta dfun_id const_meth_ids
- binds True{-from here-} mod src_loc uprag))
- )))
-
-
-lookup_unspec_inst clas maybe_tycon inst_infos
- = case filter (match_info match_inst_ty) (bagToList inst_infos) of
- [] -> Nothing
- (info:_) -> Just info
- where
- match_info match_ty (InstInfo inst_clas _ inst_ty _ _ _ _ _ from_here _ _ _)
- = from_here && clas == inst_clas &&
- match_ty inst_ty && is_plain_instance inst_ty
-
- match_inst_ty = case maybe_tycon of
- Just tycon -> match_tycon tycon
- Nothing -> match_fun
-
- match_tycon tycon inst_ty = case (maybeAppDataTyCon inst_ty) of
- Just (inst_tc,_,_) -> tycon == inst_tc
- Nothing -> False
-
- match_fun inst_ty = isFunType inst_ty
-
-
-is_plain_instance inst_ty
- = case (maybeAppDataTyCon inst_ty) of
- Just (_,tys,_) -> all isTyVarTemplateTy tys
- Nothing -> case maybeUnpackFunTy inst_ty of
- Just (arg, res) -> isTyVarTemplateTy arg && isTyVarTemplateTy res
- Nothing -> error "TcInstDecls:is_plain_instance"
--}
-\end{code}
-
-
-Checking for a decent instance type
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-@scrutiniseInstanceType@ checks the type {\em and} its syntactic constraints: