X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcMatches.lhs;h=37fbd190f811bc8b6a43d20eb20c89bb4876d875;hp=3569038ab90afeb53f36e050712863a83961e166;hb=27de38efce6d73d2a0209f803cfa98c82773e773;hpb=bfe55fb767d566b5105c5584f698af1dd4a57346 diff --git a/compiler/typecheck/TcMatches.lhs b/compiler/typecheck/TcMatches.lhs index 3569038..37fbd19 100644 --- a/compiler/typecheck/TcMatches.lhs +++ b/compiler/typecheck/TcMatches.lhs @@ -6,26 +6,16 @@ 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 HsSyn import TcRnMonad -import TcGadt import Inst import TcEnv import TcPat @@ -39,8 +29,15 @@ import TysWiredIn import PrelNames import Id import TyCon +import TysPrim import Outputable +import Util import SrcLoc +import FastString + +import Control.Monad + +#include "HsVersions.h" \end{code} %************************************************************************ @@ -80,8 +77,8 @@ tcMatchesFun fun_name inf matches exp_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} @@ -97,6 +94,13 @@ 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) @@ -105,10 +109,10 @@ tcMatchLambda match res_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 match), + doc = sep [ ptext (sLit "The lambda expression") + <+> quotes (pprSetDepth 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} @@ -118,8 +122,7 @@ tcMatchLambda match res_ty \begin{code} tcGRHSsPat :: GRHSs Name -> BoxyRhoType -> TcM (GRHSs TcId) -- Used for pattern bindings -tcGRHSsPat grhss res_ty = tcGRHSs match_ctxt grhss (emptyRefinement, res_ty) - -- emptyRefinement: no refinement in a pattern binding +tcGRHSsPat grhss res_ty = tcGRHSs match_ctxt grhss res_ty where match_ctxt = MC { mc_what = PatBindRhs, mc_body = tcBody } @@ -141,12 +144,14 @@ tcMatches :: TcMatchCtxt data TcMatchCtxt -- c.f. TcStmtCtxt, also in this module = MC { mc_what :: HsMatchContext Name, -- What kind of thing this is - mc_body :: LHsExpr Name -- Type checker for a body of an alternative - -> (Refinement, BoxyRhoType) + mc_body :: LHsExpr Name -- Type checker for a body of + -- an alternative + -> BoxyRhoType -> 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)) } ------------- @@ -169,20 +174,18 @@ 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 (co, rhs_ty) - = do { addErr (ptext SLIT("Ignoring (deprecated) result type signature") - <+> ppr res_sig) - ; tcGRHSs ctxt grhss (co, 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 -> (Refinement, BoxyRhoType) +tcGRHSs :: TcMatchCtxt -> GRHSs Name -> BoxyRhoType -> TcM (GRHSs TcId) -- Notice that we pass in the full res_ty, so that we get @@ -193,12 +196,12 @@ tcGRHSs :: TcMatchCtxt -> GRHSs Name -> (Refinement, BoxyRhoType) tcGRHSs ctxt (GRHSs grhss binds) res_ty = do { (binds', grhss') <- tcLocalBinds binds $ - mappM (wrapLocM (tcGRHS ctxt res_ty)) grhss + mapM (wrapLocM (tcGRHS ctxt res_ty)) grhss - ; returnM (GRHSs grhss' binds') } + ; return (GRHSs grhss' binds') } ------------- -tcGRHS :: TcMatchCtxt -> (Refinement, BoxyRhoType) -> GRHS Name -> TcM (GRHS TcId) +tcGRHS :: TcMatchCtxt -> BoxyRhoType -> GRHS Name -> TcM (GRHS TcId) tcGRHS ctxt res_ty (GRHS guards rhs) = do { (guards', rhs') <- tcStmts stmt_ctxt tcGuardStmt guards res_ty $ @@ -224,7 +227,7 @@ tcDoStmts :: HsStmtContext Name tcDoStmts ListComp stmts body res_ty = do { (elt_ty, coi) <- boxySplitListTy res_ty ; (stmts', body') <- tcStmts ListComp (tcLcStmt listTyCon) stmts - (emptyRefinement,elt_ty) $ + elt_ty $ tcBody body ; return $ mkHsWrapCoI coi (HsDo ListComp stmts' body' (mkListTy elt_ty)) } @@ -232,18 +235,16 @@ tcDoStmts ListComp stmts body res_ty tcDoStmts PArrComp stmts body res_ty = do { (elt_ty, coi) <- boxySplitPArrTy res_ty ; (stmts', body') <- tcStmts PArrComp (tcLcStmt parrTyCon) stmts - (emptyRefinement, elt_ty) $ + elt_ty $ tcBody body ; return $ mkHsWrapCoI coi (HsDo PArrComp stmts' body' (mkPArrTy elt_ty)) } tcDoStmts DoExpr stmts body res_ty - = do { ((m_ty, elt_ty), coi) <- boxySplitAppTy res_ty - ; let res_ty' = mkAppTy m_ty elt_ty -- The boxySplit consumes res_ty - ; (stmts', body') <- tcStmts DoExpr (tcDoStmt m_ty) stmts - (emptyRefinement, res_ty') $ + = do { (stmts', body') <- tcStmts DoExpr tcDoStmt stmts + res_ty $ tcBody body - ; return $ mkHsWrapCoI coi (HsDo DoExpr stmts' body' res_ty') } + ; return (HsDo DoExpr stmts' body' res_ty) } tcDoStmts ctxt@(MDoExpr _) stmts body res_ty = do { ((m_ty, elt_ty), coi) <- boxySplitAppTy res_ty @@ -252,7 +253,7 @@ tcDoStmts ctxt@(MDoExpr _) stmts body res_ty tcMonoExpr rhs (mkAppTy m_ty pat_ty) ; (stmts', body') <- tcStmts ctxt (tcMDoStmt tc_rhs) stmts - (emptyRefinement, res_ty') $ + res_ty' $ tcBody body ; let names = [mfixName, bindMName, thenMName, returnMName, failMName] @@ -261,14 +262,14 @@ 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 -> (Refinement, BoxyRhoType) -> TcM (LHsExpr TcId) -tcBody body (reft, res_ty) - = do { traceTc (text "tcBody" <+> ppr res_ty <+> ppr reft) - ; let (co, res_ty') = refineResType reft res_ty - ; body' <- tcPolyExpr body res_ty' - ; return (mkLHsWrap co body') } +tcBody :: LHsExpr Name -> BoxyRhoType -> TcM (LHsExpr TcId) +tcBody body res_ty + = do { traceTc (text "tcBody" <+> ppr res_ty) + ; body' <- tcPolyExpr body res_ty + ; return body' + } \end{code} @@ -282,24 +283,21 @@ tcBody body (reft, res_ty) type TcStmtChecker = forall thing. HsStmtContext Name -> Stmt Name - -> (Refinement, BoxyRhoType) -- Result type for comprehension - -> ((Refinement,BoxyRhoType) -> TcM thing) -- Checker for what follows the stmt + -> BoxyRhoType -- Result type for comprehension + -> (BoxyRhoType -> TcM thing) -- Checker for what follows the stmt -> TcM (Stmt TcId, thing) - -- The incoming BoxyRhoType may be refined by type refinements - -- before being passed to the thing_inside - tcStmts :: HsStmtContext Name -> TcStmtChecker -- NB: higher-rank type -> [LStmt Name] - -> (Refinement, BoxyRhoType) - -> ((Refinement, BoxyRhoType) -> TcM thing) + -> BoxyRhoType + -> (BoxyRhoType -> TcM thing) -> TcM ([LStmt TcId], thing) -- 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) } @@ -313,7 +311,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' $ @@ -323,17 +321,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 +tcGuardStmt _ (BindStmt pat rhs _ _) res_ty thing_inside = do { (rhs', rhs_ty) <- tcInferRho rhs ; (pat', thing) <- tcLamPat 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) @@ -344,14 +342,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 _ (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 ; 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) } @@ -382,62 +380,138 @@ tcLcStmt m_tc ctxt (ParStmt bndr_stmts_s) elt_ty thing_inside ; return (ParStmt pairs', thing) } where -- loop :: [([LStmt Name], [Name])] -> TcM ([([LStmt TcId], [TcId])], thing) - loop [] = do { thing <- thing_inside elt_ty -- No refinement from pattern + loop [] = do { thing <- thing_inside elt_ty ; return ([], thing) } -- matching in the branches 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) } ; return ( (stmts', ids) : pairs', thing ) } -tcLcStmt m_tc ctxt stmt elt_ty thing_inside +tcLcStmt m_tc ctxt (TransformStmt (stmts, binders) usingExpr maybeByExpr) elt_ty thing_inside = do + (stmts', (binders', usingExpr', maybeByExpr', thing)) <- + tcStmts (TransformStmtCtxt ctxt) (tcLcStmt m_tc) stmts elt_ty $ \elt_ty' -> do + let alphaListTy = mkTyConApp m_tc [alphaTy] + + (usingExpr', maybeByExpr') <- + case maybeByExpr of + Nothing -> do + -- We must validate that usingExpr :: forall a. [a] -> [a] + usingExpr' <- tcPolyExpr usingExpr (mkForAllTy alphaTyVar (alphaListTy `mkFunTy` alphaListTy)) + 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 + usingExpr' <- tcPolyExpr usingExpr (mkForAllTy alphaTyVar ((alphaTy `mkFunTy` tTy) `mkFunTy` (alphaListTy `mkFunTy` alphaListTy))) + return (usingExpr', Just byExpr') + + binders' <- tcLookupLocalIds binders + thing <- thing_inside elt_ty' + + return (binders', usingExpr', maybeByExpr', thing) + + return (TransformStmt (stmts', binders') usingExpr' maybeByExpr', thing) + +tcLcStmt m_tc ctxt (GroupStmt (stmts, bindersMap) groupByClause) elt_ty thing_inside = do + (stmts', (bindersMap', groupByClause', thing)) <- + tcStmts (TransformStmtCtxt ctxt) (tcLcStmt m_tc) stmts elt_ty $ \elt_ty' -> do + let alphaListTy = mkTyConApp m_tc [alphaTy] + alphaListListTy = mkTyConApp m_tc [alphaListTy] + + groupByClause' <- + case groupByClause of + GroupByNothing usingExpr -> + -- We must validate that usingExpr :: forall a. [a] -> [[a]] + 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 + + -- 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)) + eitherUsingExpr' <- + case eitherUsingExpr of + Left usingExpr -> (tcPolyExpr usingExpr expectedUsingType) >>= (return . Left) + Right usingExpr -> (tcPolyExpr (noLoc usingExpr) expectedUsingType) >>= (return . Right . unLoc) + return $ GroupBySomething eitherUsingExpr' byExpr' + + -- Find the IDs and types of all old binders + let (oldBinders, newBinders) = unzip bindersMap + oldBinders' <- tcLookupLocalIds oldBinders + + -- Ensure that every old binder of type b is linked up with its new binder which should have type [b] + let newBinders' = zipWith associateNewBinder oldBinders' newBinders + + -- Type check the thing in the environment with these new binders and return the result + thing <- tcExtendIdEnv newBinders' (thing_inside elt_ty') + return (zipEqual "tcLcStmt: Old and new binder lists were not of the same length" oldBinders' newBinders', groupByClause', thing) + + return (GroupStmt (stmts', bindersMap') groupByClause', thing) + where + associateNewBinder :: TcId -> Name -> TcId + associateNewBinder oldBinder newBinder = mkLocalId newBinder (mkTyConApp m_tc [idType oldBinder]) + +tcLcStmt _ _ stmt _ _ = pprPanic "tcLcStmt: unexpected Stmt" (ppr stmt) - + -------------------------------- -- Do-notation -- The main excitement here is dealing with rebindable syntax -tcDoStmt :: TcType -- Monad type, m - -> TcStmtChecker +tcDoStmt :: TcStmtChecker -tcDoStmt m_ty ctxt (BindStmt pat rhs bind_op fail_op) reft_res_ty@(_,res_ty) thing_inside - = do { (rhs', pat_ty) <- withBox liftedTypeKind $ \ pat_ty -> - tcMonoExpr rhs (mkAppTy m_ty pat_ty) - -- We should use type *inference* for the RHS computations, becuase of GADTs. +tcDoStmt _ (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. - - ; (pat', thing) <- tcLamPat pat pat_ty reft_res_ty thing_inside + -- We do inference on rhs, so that information about its type + -- can be refined when type-checking the pattern. + + -- 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) - -- Deal with rebindable syntax; (>>=) :: m a -> (a -> m b) -> m b - ; let bind_ty = mkFunTys [mkAppTy m_ty pat_ty, - mkFunTy pat_ty res_ty] res_ty - ; bind_op' <- tcSyntaxOp DoOrigin bind_op bind_ty -- If (but only if) the pattern can fail, -- typecheck the 'fail' operator - ; fail_op' <- if isIrrefutableHsPat pat' + ; fail_op' <- if isIrrefutableHsPat pat then return noSyntaxExpr - else tcSyntaxOp DoOrigin fail_op (mkFunTy stringTy res_ty) + else tcSyntaxOp DoOrigin fail_op (mkFunTy stringTy new_res_ty) + + ; (pat', thing) <- tcLamPat pat pat_ty new_res_ty thing_inside + ; return (BindStmt pat' rhs' bind_op' fail_op', thing) } -tcDoStmt m_ty ctxt (ExprStmt rhs then_op _) reft_res_ty@(_,res_ty) thing_inside - = do { -- Deal with rebindable syntax; (>>) :: m a -> m b -> m b - a_ty <- newFlexiTyVarTy liftedTypeKind - ; let rhs_ty = mkAppTy m_ty a_ty - then_ty = mkFunTys [rhs_ty, res_ty] res_ty - ; then_op' <- tcSyntaxOp DoOrigin then_op then_ty - ; rhs' <- tcPolyExpr rhs rhs_ty - ; thing <- thing_inside reft_res_ty +tcDoStmt _ (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) <- + withBox liftedTypeKind $ \ new_res_ty -> + tcSyntaxOp DoOrigin then_op + (mkFunTys [rhs_ty, new_res_ty] res_ty) + + ; thing <- thing_inside new_res_ty ; return (ExprStmt rhs' then_op' rhs_ty, thing) } -tcDoStmt m_ty ctxt stmt res_ty thing_inside +tcDoStmt ctxt (RecStmt {}) _ _ + = failWithTc (ptext (sLit "Illegal 'rec' stmt in") <+> pprStmtContext ctxt) + -- This case can't be caught in the renamer + -- see RnExpr.checkRecStmt + +tcDoStmt _ stmt _ _ = pprPanic "tcDoStmt: unexpected Stmt" (ppr stmt) -------------------------------- @@ -448,12 +522,12 @@ tcDoStmt m_ty 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 _ (BindStmt pat rhs _ _) res_ty thing_inside = do { (rhs', pat_ty) <- tc_rhs rhs ; (pat', thing) <- tcLamPat 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) } @@ -463,7 +537,7 @@ tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _) res_ty thing_insid ; 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 @@ -484,10 +558,10 @@ tcMDoStmt tc_rhs ctxt (RecStmt stmts laterNames recNames _ _) res_ty thing_insid = 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 (idType poly_id) mono_ty + ; 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} @@ -507,8 +581,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 @@ -517,13 +591,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") <+> pprStmtContext ctxt <> colon) - 4 (ppr stmt) -\end{code}