X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcMatches.lhs;h=3457f32ce07509226bdef966681cae71a6162933;hp=caab44ae2a515288130d8f06186fd69860f6183a;hb=fb6d198f498d4e325a540f28aaa6e1d1530839c3;hpb=210ca9c013a9cd193a78c1590e3f2ec4041f4858 diff --git a/compiler/typecheck/TcMatches.lhs b/compiler/typecheck/TcMatches.lhs index caab44a..3457f32 100644 --- a/compiler/typecheck/TcMatches.lhs +++ b/compiler/typecheck/TcMatches.lhs @@ -6,26 +6,17 @@ TcMatches: Typecheck some @Matches@ \begin{code} -{-# OPTIONS -w #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings --- for details - module TcMatches ( tcMatchesFun, tcGRHSsPat, tcMatchesCase, tcMatchLambda, - matchCtxt, TcMatchCtxt(..), + TcMatchCtxt(..), tcStmts, tcDoStmts, tcBody, tcDoStmt, tcMDoStmt, tcGuardStmt ) where -#include "HsVersions.h" - -import {-# SOURCE #-} TcExpr( tcSyntaxOp, tcInferRho, tcMonoExpr, tcPolyExpr ) +import {-# SOURCE #-} TcExpr( tcSyntaxOp, tcInferRhoNC, + tcMonoExpr, tcMonoExprNC, tcPolyExpr ) import HsSyn import TcRnMonad -import TcGadt import Inst import TcEnv import TcPat @@ -43,8 +34,11 @@ import TysPrim import Outputable import Util import SrcLoc +import FastString import Control.Monad + +#include "HsVersions.h" \end{code} %************************************************************************ @@ -80,12 +74,12 @@ tcMatchesFun fun_name inf matches exp_ty -- This is one of two places places we call subFunTys -- The point is that if expected_y is a "hole", we want -- to make pat_tys and rhs_ty as "holes" too. - ; subFunTys doc n_pats exp_ty $ \ pat_tys rhs_ty -> + ; subFunTys doc n_pats exp_ty (Just (FunSigCtxt fun_name)) $ \ pat_tys rhs_ty -> tcMatches match_ctxt pat_tys rhs_ty matches } where - doc = ptext SLIT("The equation(s) for") <+> quotes (ppr fun_name) - <+> ptext SLIT("have") <+> speakNOf n_pats (ptext SLIT("argument")) + doc = ptext (sLit "The equation(s) for") <+> quotes (ppr fun_name) + <+> ptext (sLit "have") <+> speakNOf n_pats (ptext (sLit "argument")) n_pats = matchGroupArity matches match_ctxt = MC { mc_what = FunRhs fun_name inf, mc_body = tcBody } \end{code} @@ -101,18 +95,26 @@ tcMatchesCase :: TcMatchCtxt -- Case context -> TcM (MatchGroup TcId) -- Translated alternatives tcMatchesCase ctxt scrut_ty matches res_ty + | isEmptyMatchGroup matches + = -- Allow empty case expressions + do { -- Make sure we follow the invariant that res_ty is filled in + res_ty' <- refineBoxToTau res_ty + ; return (MatchGroup [] (mkFunTys [scrut_ty] res_ty')) } + + | otherwise = tcMatches ctxt [scrut_ty] res_ty matches tcMatchLambda :: MatchGroup Name -> BoxyRhoType -> TcM (HsWrapper, MatchGroup TcId) tcMatchLambda match res_ty - = subFunTys doc n_pats res_ty $ \ pat_tys rhs_ty -> + = subFunTys doc n_pats res_ty Nothing $ \ pat_tys rhs_ty -> tcMatches match_ctxt pat_tys rhs_ty match where n_pats = matchGroupArity match - doc = sep [ ptext SLIT("The lambda expression") - <+> quotes (pprSetDepth 1 $ pprMatches (LambdaExpr :: HsMatchContext Name) match), + doc = sep [ ptext (sLit "The lambda expression") + <+> quotes (pprSetDepth (PartWay 1) $ + pprMatches (LambdaExpr :: HsMatchContext Name) match), -- The pprSetDepth makes the abstraction print briefly - ptext SLIT("has") <+> speakNOf n_pats (ptext SLIT("argument"))] + ptext (sLit "has") <+> speakNOf n_pats (ptext (sLit "argument"))] match_ctxt = MC { mc_what = LambdaExpr, mc_body = tcBody } \end{code} @@ -150,7 +152,8 @@ data TcMatchCtxt -- c.f. TcStmtCtxt, also in this module -> TcM (LHsExpr TcId) } tcMatches ctxt pat_tys rhs_ty (MatchGroup matches _) - = do { matches' <- mapM (tcMatch ctxt pat_tys rhs_ty) matches + = ASSERT( not (null matches) ) -- Ensure that rhs_ty is filled in + do { matches' <- mapM (tcMatch ctxt pat_tys rhs_ty) matches ; return (MatchGroup matches' (mkFunTys pat_tys rhs_ty)) } ------------- @@ -165,7 +168,7 @@ tcMatch ctxt pat_tys rhs_ty match where tc_match ctxt pat_tys rhs_ty match@(Match pats maybe_rhs_sig grhss) = add_match_ctxt match $ - do { (pats', grhss') <- tcLamPats pats pat_tys rhs_ty $ + do { (pats', grhss') <- tcPats (mc_what ctxt) pats pat_tys rhs_ty $ tc_grhss ctxt maybe_rhs_sig grhss ; return (Match pats' Nothing grhss') } @@ -173,17 +176,15 @@ tcMatch ctxt pat_tys rhs_ty match = tcGRHSs ctxt grhss rhs_ty -- No result signature -- Result type sigs are no longer supported - tc_grhss ctxt (Just res_sig) grhss rhs_ty - = do { addErr (ptext SLIT("Ignoring (deprecated) result type signature") - <+> ppr res_sig) - ; tcGRHSs ctxt grhss rhs_ty } + tc_grhss _ (Just {}) _ _ + = panic "tc_ghrss" -- Rejected by renamer -- For (\x -> e), tcExpr has already said "In the expresssion \x->e" -- so we don't want to add "In the lambda abstraction \x->e" add_match_ctxt match thing_inside = case mc_what ctxt of LambdaExpr -> thing_inside - m_ctxt -> addErrCtxt (matchCtxt m_ctxt match) thing_inside + m_ctxt -> addErrCtxt (pprMatchInCtxt m_ctxt match) thing_inside ------------- tcGRHSs :: TcMatchCtxt -> GRHSs Name -> BoxyRhoType @@ -263,12 +264,12 @@ tcDoStmts ctxt@(MDoExpr _) stmts body res_ty mkHsWrapCoI coi (HsDo (MDoExpr (names `zip` insts)) stmts' body' res_ty') } -tcDoStmts ctxt stmts body res_ty = pprPanic "tcDoStmts" (pprStmtContext ctxt) +tcDoStmts ctxt _ _ _ = pprPanic "tcDoStmts" (pprStmtContext ctxt) tcBody :: LHsExpr Name -> BoxyRhoType -> TcM (LHsExpr TcId) tcBody body res_ty = do { traceTc (text "tcBody" <+> ppr res_ty) - ; body' <- tcPolyExpr body res_ty + ; body' <- tcMonoExpr body res_ty ; return body' } \end{code} @@ -298,7 +299,7 @@ tcStmts :: HsStmtContext Name -- Note the higher-rank type. stmt_chk is applied at different -- types in the equations for tcStmts -tcStmts ctxt stmt_chk [] res_ty thing_inside +tcStmts _ _ [] res_ty thing_inside = do { thing <- thing_inside res_ty ; return ([], thing) } @@ -312,7 +313,7 @@ tcStmts ctxt stmt_chk (L loc (LetStmt binds) : stmts) res_ty thing_inside tcStmts ctxt stmt_chk (L loc stmt : stmts) res_ty thing_inside = do { (stmt', (stmts', thing)) <- setSrcSpan loc $ - addErrCtxt (stmtCtxt ctxt stmt) $ + addErrCtxt (pprStmtInCtxt ctxt stmt) $ stmt_chk ctxt stmt res_ty $ \ res_ty' -> popErrCtxt $ tcStmts ctxt stmt_chk stmts res_ty' $ @@ -322,17 +323,17 @@ tcStmts ctxt stmt_chk (L loc stmt : stmts) res_ty thing_inside -------------------------------- -- Pattern guards tcGuardStmt :: TcStmtChecker -tcGuardStmt ctxt (ExprStmt guard _ _) res_ty thing_inside +tcGuardStmt _ (ExprStmt guard _ _) res_ty thing_inside = do { guard' <- tcMonoExpr guard boolTy ; thing <- thing_inside res_ty ; return (ExprStmt guard' noSyntaxExpr boolTy, thing) } tcGuardStmt ctxt (BindStmt pat rhs _ _) res_ty thing_inside - = do { (rhs', rhs_ty) <- tcInferRho rhs - ; (pat', thing) <- tcLamPat pat rhs_ty res_ty thing_inside + = do { (rhs', rhs_ty) <- tcInferRhoNC rhs -- Stmt has a context already + ; (pat', thing) <- tcPat (StmtCtxt ctxt) pat rhs_ty res_ty thing_inside ; return (BindStmt pat' rhs' noSyntaxExpr noSyntaxExpr, thing) } -tcGuardStmt ctxt stmt res_ty thing_inside +tcGuardStmt _ stmt _ _ = pprPanic "tcGuardStmt: unexpected Stmt" (ppr stmt) @@ -343,14 +344,14 @@ tcLcStmt :: TyCon -- The list/Parray type constructor ([] or PArray) -> TcStmtChecker -- A generator, pat <- rhs -tcLcStmt m_tc ctxt (BindStmt pat rhs _ _) res_ty thing_inside +tcLcStmt m_tc ctxt (BindStmt pat rhs _ _) res_ty thing_inside = do { (rhs', pat_ty) <- withBox liftedTypeKind $ \ ty -> tcMonoExpr rhs (mkTyConApp m_tc [ty]) - ; (pat', thing) <- tcLamPat pat pat_ty res_ty thing_inside + ; (pat', thing) <- tcPat (StmtCtxt ctxt) pat pat_ty res_ty thing_inside ; return (BindStmt pat' rhs' noSyntaxExpr noSyntaxExpr, thing) } -- A boolean guard -tcLcStmt m_tc ctxt (ExprStmt rhs _ _) res_ty thing_inside +tcLcStmt _ _ (ExprStmt rhs _ _) res_ty thing_inside = do { rhs' <- tcMonoExpr rhs boolTy ; thing <- thing_inside res_ty ; return (ExprStmt rhs' noSyntaxExpr boolTy, thing) } @@ -386,7 +387,7 @@ tcLcStmt m_tc ctxt (ParStmt bndr_stmts_s) elt_ty thing_inside loop ((stmts, names) : pairs) = do { (stmts', (ids, pairs', thing)) - <- tcStmts ctxt (tcLcStmt m_tc) stmts elt_ty $ \ elt_ty' -> + <- tcStmts ctxt (tcLcStmt m_tc) stmts elt_ty $ \ _elt_ty' -> do { ids <- tcLookupLocalIds names ; (pairs', thing) <- loop pairs ; return (ids, pairs', thing) } @@ -405,7 +406,7 @@ tcLcStmt m_tc ctxt (TransformStmt (stmts, binders) usingExpr maybeByExpr) elt_ty return (usingExpr', Nothing) Just byExpr -> do -- We must infer a type such that e :: t and then check that usingExpr :: forall a. (a -> t) -> [a] -> [a] - (byExpr', tTy) <- tcInferRho byExpr + (byExpr', tTy) <- tcInferRhoNC byExpr usingExpr' <- tcPolyExpr usingExpr (mkForAllTy alphaTyVar ((alphaTy `mkFunTy` tTy) `mkFunTy` (alphaListTy `mkFunTy` alphaListTy))) return (usingExpr', Just byExpr') @@ -429,7 +430,7 @@ tcLcStmt m_tc ctxt (GroupStmt (stmts, bindersMap) groupByClause) elt_ty thing_in tcPolyExpr usingExpr (mkForAllTy alphaTyVar (alphaListTy `mkFunTy` alphaListListTy)) >>= (return . GroupByNothing) GroupBySomething eitherUsingExpr byExpr -> do -- We must infer a type such that byExpr :: t - (byExpr', tTy) <- tcInferRho byExpr + (byExpr', tTy) <- tcInferRhoNC byExpr -- If it exists, we then check that usingExpr :: forall a. (a -> t) -> [a] -> [[a]] let expectedUsingType = mkForAllTy alphaTyVar ((alphaTy `mkFunTy` tTy) `mkFunTy` (alphaListTy `mkFunTy` alphaListListTy)) @@ -455,7 +456,7 @@ tcLcStmt m_tc ctxt (GroupStmt (stmts, bindersMap) groupByClause) elt_ty thing_in associateNewBinder :: TcId -> Name -> TcId associateNewBinder oldBinder newBinder = mkLocalId newBinder (mkTyConApp m_tc [idType oldBinder]) -tcLcStmt m_tc ctxt stmt elt_ty thing_inside +tcLcStmt _ _ stmt _ _ = pprPanic "tcLcStmt: unexpected Stmt" (ppr stmt) -------------------------------- @@ -465,24 +466,22 @@ tcLcStmt m_tc ctxt stmt elt_ty thing_inside tcDoStmt :: TcStmtChecker tcDoStmt ctxt (BindStmt pat rhs bind_op fail_op) res_ty thing_inside - = do { (rhs', rhs_ty) <- tcInferRho rhs - -- We should use type *inference* for the RHS computations, - -- becuase of GADTs. - -- do { pat <- rhs; } - -- is rather like - -- case rhs of { pat -> } - -- We do inference on rhs, so that information about its type - -- can be refined when type-checking the pattern. + = do { -- Deal with rebindable syntax: + -- (>>=) :: rhs_ty -> (pat_ty -> new_res_ty) -> res_ty + -- This level of generality is needed for using do-notation + -- in full generality; see Trac #1537 + + -- I'd like to put this *after* the tcSyntaxOp + -- (see Note [Treat rebindable syntax first], but that breaks + -- the rigidity info for GADTs. When we move to the new story + -- for GADTs, we can move this after tcSyntaxOp + (rhs', rhs_ty) <- tcInferRhoNC rhs - -- Deal with rebindable syntax: - -- (>>=) :: rhs_ty -> (pat_ty -> new_res_ty) -> res_ty - -- This level of generality is needed for using do-notation - -- in full generality; see Trac #1537 ; ((bind_op', new_res_ty), pat_ty) <- withBox liftedTypeKind $ \ pat_ty -> withBox liftedTypeKind $ \ new_res_ty -> tcSyntaxOp DoOrigin bind_op - (mkFunTys [rhs_ty, mkFunTy pat_ty new_res_ty] res_ty) + (mkFunTys [rhs_ty, mkFunTy pat_ty new_res_ty] res_ty) -- If (but only if) the pattern can fail, -- typecheck the 'fail' operator @@ -490,31 +489,94 @@ tcDoStmt ctxt (BindStmt pat rhs bind_op fail_op) res_ty thing_inside then return noSyntaxExpr else tcSyntaxOp DoOrigin fail_op (mkFunTy stringTy new_res_ty) - ; (pat', thing) <- tcLamPat pat pat_ty new_res_ty thing_inside + -- We should typecheck the RHS *before* the pattern, + -- because of GADTs. + -- do { pat <- rhs; } + -- is rather like + -- case rhs of { pat -> } + -- We do inference on rhs, so that information about its type + -- can be refined when type-checking the pattern. - ; return (BindStmt pat' rhs' bind_op' fail_op', thing) } + ; (pat', thing) <- tcPat (StmtCtxt ctxt) pat pat_ty new_res_ty thing_inside + ; return (BindStmt pat' rhs' bind_op' fail_op', thing) } -tcDoStmt ctxt (ExprStmt rhs then_op _) res_ty thing_inside - = do { (rhs', rhs_ty) <- tcInferRho rhs - -- Deal with rebindable syntax; (>>) :: rhs_ty -> new_res_ty -> res_ty - ; (then_op', new_res_ty) <- +tcDoStmt _ (ExprStmt rhs then_op _) res_ty thing_inside + = do { -- Deal with rebindable syntax; + -- (>>) :: rhs_ty -> new_res_ty -> res_ty + -- See also Note [Treat rebindable syntax first] + ((then_op', rhs_ty), new_res_ty) <- withBox liftedTypeKind $ \ new_res_ty -> + withBox liftedTypeKind $ \ rhs_ty -> tcSyntaxOp DoOrigin then_op (mkFunTys [rhs_ty, new_res_ty] res_ty) + ; rhs' <- tcMonoExprNC rhs rhs_ty ; thing <- thing_inside new_res_ty ; return (ExprStmt rhs' then_op' rhs_ty, thing) } -tcDoStmt ctxt (RecStmt {}) res_ty thing_inside - = failWithTc (ptext SLIT("Illegal 'rec' stmt in") <+> pprStmtContext ctxt) - -- This case can't be caught in the renamer - -- see RnExpr.checkRecStmt +tcDoStmt ctxt (RecStmt { recS_stmts = stmts, recS_later_ids = later_names + , recS_rec_ids = rec_names, recS_ret_fn = ret_op + , recS_mfix_fn = mfix_op, recS_bind_fn = bind_op }) + res_ty thing_inside + = do { let tup_names = rec_names ++ filterOut (`elem` rec_names) later_names + ; tup_elt_tys <- newFlexiTyVarTys (length tup_names) liftedTypeKind + ; let tup_ids = zipWith mkLocalId tup_names tup_elt_tys + tup_ty = mkBoxedTupleTy tup_elt_tys + + ; tcExtendIdEnv tup_ids $ do + { ((stmts', (ret_op', tup_rets)), stmts_ty) + <- withBox liftedTypeKind $ \ stmts_ty -> + tcStmts ctxt tcDoStmt stmts stmts_ty $ \ inner_res_ty -> + do { tup_rets <- zipWithM tc_ret tup_names tup_elt_tys + ; ret_op' <- tcSyntaxOp DoOrigin ret_op (mkFunTy tup_ty inner_res_ty) + ; return (ret_op', tup_rets) } + + ; (mfix_op', mfix_res_ty) <- withBox liftedTypeKind $ \ mfix_res_ty -> + tcSyntaxOp DoOrigin mfix_op + (mkFunTy (mkFunTy tup_ty stmts_ty) mfix_res_ty) + + ; (bind_op', new_res_ty) <- withBox liftedTypeKind $ \ new_res_ty -> + tcSyntaxOp DoOrigin bind_op + (mkFunTys [mfix_res_ty, mkFunTy tup_ty new_res_ty] res_ty) + + ; (thing,lie) <- getLIE (thing_inside new_res_ty) + ; lie_binds <- bindInstsOfLocalFuns lie tup_ids + + ; let rec_ids = takeList rec_names tup_ids + ; later_ids <- tcLookupLocalIds later_names + ; traceTc (text "tcdo" <+> vcat [ppr rec_ids <+> ppr (map idType rec_ids), + ppr later_ids <+> ppr (map idType later_ids)]) + ; return (RecStmt { recS_stmts = stmts', recS_later_ids = later_ids + , recS_rec_ids = rec_ids, recS_ret_fn = ret_op' + , recS_mfix_fn = mfix_op', recS_bind_fn = bind_op' + , recS_rec_rets = tup_rets, recS_dicts = lie_binds }, thing) + }} + where + -- Unify the types of the "final" Ids with those of "knot-tied" Ids + tc_ret rec_name mono_ty + = do { poly_id <- tcLookupId rec_name + -- poly_id may have a polymorphic type + -- but mono_ty is just a monomorphic type variable + ; co_fn <- tcSubExp DoOrigin (idType poly_id) mono_ty + ; return (mkHsWrap co_fn (HsVar poly_id)) } -tcDoStmt ctxt stmt res_ty thing_inside +tcDoStmt _ stmt _ _ = pprPanic "tcDoStmt: unexpected Stmt" (ppr stmt) +\end{code} +Note [Treat rebindable syntax first] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +When typechecking + do { bar; ... } :: IO () +we want to typecheck 'bar' in the knowledge that it should be an IO thing, +pushing info from the context into the RHS. To do this, we check the +rebindable syntax first, and push that information into (tcMonoExprNC rhs). +Otherwise the error shows up when cheking the rebindable syntax, and +the expected/inferred stuff is back to front (see Trac #3613). + +\begin{code} -------------------------------- -- Mdo-notation -- The distinctive features here are @@ -523,22 +585,22 @@ tcDoStmt ctxt stmt res_ty thing_inside tcMDoStmt :: (LHsExpr Name -> TcM (LHsExpr TcId, TcType)) -- RHS inference -> TcStmtChecker -tcMDoStmt tc_rhs ctxt (BindStmt pat rhs bind_op fail_op) res_ty thing_inside +tcMDoStmt tc_rhs ctxt (BindStmt pat rhs _ _) res_ty thing_inside = do { (rhs', pat_ty) <- tc_rhs rhs - ; (pat', thing) <- tcLamPat pat pat_ty res_ty thing_inside + ; (pat', thing) <- tcPat (StmtCtxt ctxt) pat pat_ty res_ty thing_inside ; return (BindStmt pat' rhs' noSyntaxExpr noSyntaxExpr, thing) } -tcMDoStmt tc_rhs ctxt (ExprStmt rhs then_op _) res_ty thing_inside +tcMDoStmt tc_rhs _ (ExprStmt rhs _ _) res_ty thing_inside = do { (rhs', elt_ty) <- tc_rhs rhs ; thing <- thing_inside res_ty ; return (ExprStmt rhs' noSyntaxExpr elt_ty, thing) } -tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _) res_ty thing_inside +tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _ _ _ _) res_ty thing_inside = do { rec_tys <- newFlexiTyVarTys (length recNames) liftedTypeKind ; let rec_ids = zipWith mkLocalId recNames rec_tys ; tcExtendIdEnv rec_ids $ do { (stmts', (later_ids, rec_rets)) - <- tcStmts ctxt (tcMDoStmt tc_rhs) stmts res_ty $ \ res_ty' -> + <- tcStmts ctxt (tcMDoStmt tc_rhs) stmts res_ty $ \ _res_ty' -> -- ToDo: res_ty not really right do { rec_rets <- zipWithM tc_ret recNames rec_tys ; later_ids <- tcLookupLocalIds laterNames @@ -551,7 +613,7 @@ tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _) res_ty thing_insid -- (see note [RecStmt] in HsExpr) ; lie_binds <- bindInstsOfLocalFuns lie later_ids - ; return (RecStmt stmts' later_ids rec_ids rec_rets lie_binds, thing) + ; return (RecStmt stmts' later_ids rec_ids noSyntaxExpr noSyntaxExpr noSyntaxExpr rec_rets lie_binds, thing) }} where -- Unify the types of the "final" Ids with those of "knot-tied" Ids @@ -562,7 +624,7 @@ tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _) res_ty thing_insid ; co_fn <- tcSubExp DoOrigin (idType poly_id) mono_ty ; return (mkHsWrap co_fn (HsVar poly_id)) } -tcMDoStmt tc_rhs ctxt stmt res_ty thing_inside +tcMDoStmt _ _ stmt _ _ = pprPanic "tcMDoStmt: unexpected Stmt" (ppr stmt) \end{code} @@ -582,8 +644,8 @@ checkArgs :: Name -> MatchGroup Name -> TcM () checkArgs fun (MatchGroup (match1:matches) _) | null bad_matches = return () | otherwise - = failWithTc (vcat [ptext SLIT("Equations for") <+> quotes (ppr fun) <+> - ptext SLIT("have different numbers of arguments"), + = failWithTc (vcat [ptext (sLit "Equations for") <+> quotes (ppr fun) <+> + ptext (sLit "have different numbers of arguments"), nest 2 (ppr (getLoc match1)), nest 2 (ppr (getLoc (head bad_matches)))]) where @@ -592,13 +654,6 @@ checkArgs fun (MatchGroup (match1:matches) _) args_in_match :: LMatch Name -> Int args_in_match (L _ (Match pats _ _)) = length pats -checkArgs fun other = panic "TcPat.checkArgs" -- Matches always non-empty +checkArgs _ _ = panic "TcPat.checkArgs" -- Matches always non-empty \end{code} -\begin{code} -matchCtxt ctxt match = hang (ptext SLIT("In") <+> pprMatchContext ctxt <> colon) - 4 (pprMatch ctxt match) - -stmtCtxt ctxt stmt = hang (ptext SLIT("In a stmt of") <+> pprStmtContext ctxt <> colon) - 4 (ppr stmt) -\end{code}