X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Frename%2FRnExpr.lhs;h=12e96d89c9b6284d7b77af2103b3b7bc26430d12;hb=58521c72cec262496dabf5fffb057d25ab17a0f7;hp=3b85b3df4d3d4947e1980fd8faf6213c823c8f41;hpb=c24a860db326c7c1c7bab837b62147a984d5aecd;p=ghc-hetmet.git diff --git a/compiler/rename/RnExpr.lhs b/compiler/rename/RnExpr.lhs index 3b85b3d..12e96d8 100644 --- a/compiler/rename/RnExpr.lhs +++ b/compiler/rename/RnExpr.lhs @@ -20,18 +20,19 @@ module RnExpr ( import {-# SOURCE #-} TcSplice( runQuasiQuoteExpr ) #endif /* GHCI */ -import RnSource ( rnSrcDecls, rnSplice, checkTH ) +import RnSource ( rnSrcDecls ) import RnBinds ( rnLocalBindsAndThen, rnValBindsLHS, rnValBindsRHS, rnMatchGroup, makeMiniFixityEnv) import HsSyn import TcRnMonad +import TcEnv ( thRnBrack ) import RnEnv -import RnTypes ( rnHsTypeFVs, +import RnTypes ( rnHsTypeFVs, rnSplice, checkTH, mkOpFormRn, mkOpAppRn, mkNegAppRn, checkSectionPrec) import RnPat import DynFlags ( DynFlag(..) ) import BasicTypes ( FixityDirection(..) ) -import PrelNames ( thFAKE, hasKey, assertIdKey, assertErrorName, +import PrelNames ( hasKey, assertIdKey, assertErrorName, loopAName, choiceAName, appAName, arrAName, composeAName, firstAName, negateName, thenMName, bindMName, failMName, groupWithName ) @@ -49,7 +50,6 @@ import SrcLoc import FastString import List ( unzip4 ) -import Control.Monad \end{code} @@ -60,15 +60,6 @@ thenM = (>>=) thenM_ :: Monad a => a b -> a c -> a c thenM_ = (>>) - -returnM :: Monad m => a -> m a -returnM = return - -mappM :: (Monad m) => (a -> m b) -> [a] -> m [b] -mappM = mapM - -checkM :: Monad m => Bool -> m () -> m () -checkM = unless \end{code} %************************************************************************ @@ -81,7 +72,7 @@ checkM = unless rnExprs :: [LHsExpr RdrName] -> RnM ([LHsExpr Name], FreeVars) rnExprs ls = rnExprs' ls emptyUniqSet where - rnExprs' [] acc = returnM ([], acc) + rnExprs' [] acc = return ([], acc) rnExprs' (expr:exprs) acc = rnLExpr expr `thenM` \ (expr', fvExpr) -> @@ -91,7 +82,7 @@ rnExprs ls = rnExprs' ls emptyUniqSet acc' = acc `plusFV` fvExpr in acc' `seq` rnExprs' exprs acc' `thenM` \ (exprs', fvExprs) -> - returnM (expr':exprs', fvExprs) + return (expr':exprs', fvExprs) \end{code} Variables. We look up the variable and return the resulting name. @@ -102,21 +93,24 @@ rnLExpr = wrapLocFstM rnExpr rnExpr :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars) +finishHsVar :: Name -> RnM (HsExpr Name, FreeVars) +-- Separated from rnExpr because it's also used +-- when renaming infix expressions +-- See Note [Adding the implicit parameter to 'assert'] +finishHsVar name + = do { ignore_asserts <- doptM Opt_IgnoreAsserts + ; if ignore_asserts || not (name `hasKey` assertIdKey) + then return (HsVar name, unitFV name) + else do { e <- mkAssertErrorExpr + ; return (e, unitFV name) } } + rnExpr (HsVar v) - = do name <- lookupOccRn v - ignore_asserts <- doptM Opt_IgnoreAsserts - finish_var ignore_asserts name - where - finish_var ignore_asserts name - | ignore_asserts || not (name `hasKey` assertIdKey) - = return (HsVar name, unitFV name) - | otherwise - = do { (e, fvs) <- mkAssertErrorExpr - ; return (e, fvs `addOneFV` name) } + = do name <- lookupOccRn v + finishHsVar name rnExpr (HsIPVar v) = newIPNameRn v `thenM` \ name -> - returnM (HsIPVar name, emptyFVs) + return (HsIPVar name, emptyFVs) rnExpr (HsLit lit@(HsString s)) = do { @@ -125,59 +119,56 @@ rnExpr (HsLit lit@(HsString s)) rnExpr (HsOverLit (mkHsIsString s placeHolderType)) else -- Same as below rnLit lit `thenM_` - returnM (HsLit lit, emptyFVs) + return (HsLit lit, emptyFVs) } rnExpr (HsLit lit) = rnLit lit `thenM_` - returnM (HsLit lit, emptyFVs) + return (HsLit lit, emptyFVs) rnExpr (HsOverLit lit) = rnOverLit lit `thenM` \ (lit', fvs) -> - returnM (HsOverLit lit', fvs) + return (HsOverLit lit', fvs) rnExpr (HsApp fun arg) = rnLExpr fun `thenM` \ (fun',fvFun) -> rnLExpr arg `thenM` \ (arg',fvArg) -> - returnM (HsApp fun' arg', fvFun `plusFV` fvArg) - -rnExpr (OpApp e1 op _ e2) - = rnLExpr e1 `thenM` \ (e1', fv_e1) -> - rnLExpr e2 `thenM` \ (e2', fv_e2) -> - rnLExpr op `thenM` \ (op'@(L _ (HsVar op_name)), fv_op) -> - + return (HsApp fun' arg', fvFun `plusFV` fvArg) + +rnExpr (OpApp e1 (L op_loc (HsVar op_rdr)) _ e2) + = do { (e1', fv_e1) <- rnLExpr e1 + ; (e2', fv_e2) <- rnLExpr e2 + ; op_name <- setSrcSpan op_loc (lookupOccRn op_rdr) + ; (op', fv_op) <- finishHsVar op_name + -- NB: op' is usually just a variable, but might be + -- an applicatoin (assert "Foo.hs:47") -- Deal with fixity -- When renaming code synthesised from "deriving" declarations -- we used to avoid fixity stuff, but we can't easily tell any -- more, so I've removed the test. Adding HsPars in TcGenDeriv -- should prevent bad things happening. - lookupFixityRn op_name `thenM` \ fixity -> - mkOpAppRn e1' op' fixity e2' `thenM` \ final_e -> - - returnM (final_e, - fv_e1 `plusFV` fv_op `plusFV` fv_e2) + ; fixity <- lookupFixityRn op_name + ; final_e <- mkOpAppRn e1' (L op_loc op') fixity e2' + ; return (final_e, fv_e1 `plusFV` fv_op `plusFV` fv_e2) } rnExpr (NegApp e _) = rnLExpr e `thenM` \ (e', fv_e) -> lookupSyntaxName negateName `thenM` \ (neg_name, fv_neg) -> mkNegAppRn e' neg_name `thenM` \ final_e -> - returnM (final_e, fv_e `plusFV` fv_neg) - -rnExpr (HsPar e) - = rnLExpr e `thenM` \ (e', fvs_e) -> - returnM (HsPar e', fvs_e) + return (final_e, fv_e `plusFV` fv_neg) +------------------------------------------ -- Template Haskell extensions -- Don't ifdef-GHCI them because we want to fail gracefully -- (not with an rnExpr crash) in a stage-1 compiler. rnExpr e@(HsBracket br_body) = checkTH e "bracket" `thenM_` rnBracket br_body `thenM` \ (body', fvs_e) -> - returnM (HsBracket body', fvs_e) + return (HsBracket body', fvs_e) rnExpr (HsSpliceE splice) = rnSplice splice `thenM` \ (splice', fvs) -> - returnM (HsSpliceE splice', fvs) + return (HsSpliceE splice', fvs) #ifndef GHCI rnExpr e@(HsQuasiQuoteE _) = pprPanic "Cant do quasiquotation without GHCi" (ppr e) @@ -186,45 +177,54 @@ rnExpr (HsQuasiQuoteE qq) = rnQuasiQuote qq `thenM` \ (qq', fvs_qq) -> runQuasiQuoteExpr qq' `thenM` \ (L _ expr') -> rnExpr expr' `thenM` \ (expr'', fvs_expr) -> - returnM (expr'', fvs_qq `plusFV` fvs_expr) + return (expr'', fvs_qq `plusFV` fvs_expr) #endif /* GHCI */ -rnExpr section@(SectionL expr op) - = rnLExpr expr `thenM` \ (expr', fvs_expr) -> - rnLExpr op `thenM` \ (op', fvs_op) -> - checkSectionPrec InfixL section op' expr' `thenM_` - returnM (SectionL expr' op', fvs_op `plusFV` fvs_expr) +--------------------------------------------- +-- Sections +-- See Note [Parsing sections] in Parser.y.pp +rnExpr (HsPar (L loc (section@(SectionL {})))) + = do { (section', fvs) <- rnSection section + ; return (HsPar (L loc section'), fvs) } + +rnExpr (HsPar (L loc (section@(SectionR {})))) + = do { (section', fvs) <- rnSection section + ; return (HsPar (L loc section'), fvs) } + +rnExpr (HsPar e) + = do { (e', fvs_e) <- rnLExpr e + ; return (HsPar e', fvs_e) } -rnExpr section@(SectionR op expr) - = rnLExpr op `thenM` \ (op', fvs_op) -> - rnLExpr expr `thenM` \ (expr', fvs_expr) -> - checkSectionPrec InfixR section op' expr' `thenM_` - returnM (SectionR op' expr', fvs_op `plusFV` fvs_expr) +rnExpr expr@(SectionL {}) + = do { addErr (sectionErr expr); rnSection expr } +rnExpr expr@(SectionR {}) + = do { addErr (sectionErr expr); rnSection expr } +--------------------------------------------- rnExpr (HsCoreAnn ann expr) = rnLExpr expr `thenM` \ (expr', fvs_expr) -> - returnM (HsCoreAnn ann expr', fvs_expr) + return (HsCoreAnn ann expr', fvs_expr) rnExpr (HsSCC lbl expr) = rnLExpr expr `thenM` \ (expr', fvs_expr) -> - returnM (HsSCC lbl expr', fvs_expr) + return (HsSCC lbl expr', fvs_expr) rnExpr (HsTickPragma info expr) = rnLExpr expr `thenM` \ (expr', fvs_expr) -> - returnM (HsTickPragma info expr', fvs_expr) + return (HsTickPragma info expr', fvs_expr) rnExpr (HsLam matches) = rnMatchGroup LambdaExpr matches `thenM` \ (matches', fvMatch) -> - returnM (HsLam matches', fvMatch) + return (HsLam matches', fvMatch) rnExpr (HsCase expr matches) = rnLExpr expr `thenM` \ (new_expr, e_fvs) -> rnMatchGroup CaseAlt matches `thenM` \ (new_matches, ms_fvs) -> - returnM (HsCase new_expr new_matches, e_fvs `plusFV` ms_fvs) + return (HsCase new_expr new_matches, e_fvs `plusFV` ms_fvs) rnExpr (HsLet binds expr) = rnLocalBindsAndThen binds $ \ binds' -> rnLExpr expr `thenM` \ (expr',fvExpr) -> - returnM (HsLet binds' expr', fvExpr) + return (HsLet binds' expr', fvExpr) rnExpr (HsDo do_or_lc stmts body _) = do { ((stmts', body'), fvs) <- rnStmts do_or_lc stmts $ @@ -233,16 +233,20 @@ rnExpr (HsDo do_or_lc stmts body _) rnExpr (ExplicitList _ exps) = rnExprs exps `thenM` \ (exps', fvs) -> - returnM (ExplicitList placeHolderType exps', fvs) + return (ExplicitList placeHolderType exps', fvs) rnExpr (ExplicitPArr _ exps) = rnExprs exps `thenM` \ (exps', fvs) -> - returnM (ExplicitPArr placeHolderType exps', fvs) + return (ExplicitPArr placeHolderType exps', fvs) -rnExpr (ExplicitTuple exps boxity) - = checkTupSize (length exps) `thenM_` - rnExprs exps `thenM` \ (exps', fvs) -> - returnM (ExplicitTuple exps' boxity, fvs) +rnExpr (ExplicitTuple tup_args boxity) + = do { checkTupleSection tup_args + ; checkTupSize (length tup_args) + ; (tup_args', fvs) <- mapAndUnzipM rnTupArg tup_args + ; return (ExplicitTuple tup_args' boxity, plusFVs fvs) } + where + rnTupArg (Present e) = do { (e',fvs) <- rnLExpr e; return (Present e', fvs) } + rnTupArg (Missing _) = return (Missing placeHolderType, emptyFVs) rnExpr (RecordCon con_id _ rbinds) = do { conname <- lookupLocatedOccRn con_id @@ -268,21 +272,21 @@ rnExpr (HsIf p b1 b2) = rnLExpr p `thenM` \ (p', fvP) -> rnLExpr b1 `thenM` \ (b1', fvB1) -> rnLExpr b2 `thenM` \ (b2', fvB2) -> - returnM (HsIf p' b1' b2', plusFVs [fvP, fvB1, fvB2]) + return (HsIf p' b1' b2', plusFVs [fvP, fvB1, fvB2]) rnExpr (HsType a) = rnHsTypeFVs doc a `thenM` \ (t, fvT) -> - returnM (HsType t, fvT) + return (HsType t, fvT) where doc = text "In a type argument" rnExpr (ArithSeq _ seq) = rnArithSeq seq `thenM` \ (new_seq, fvs) -> - returnM (ArithSeq noPostTcExpr new_seq, fvs) + return (ArithSeq noPostTcExpr new_seq, fvs) rnExpr (PArrSeq _ seq) = rnArithSeq seq `thenM` \ (new_seq, fvs) -> - returnM (PArrSeq noPostTcExpr new_seq, fvs) + return (PArrSeq noPostTcExpr new_seq, fvs) \end{code} These three are pattern syntax appearing in expressions. @@ -307,12 +311,12 @@ rnExpr (HsProc pat body) = newArrowScope $ rnPatsAndThen_LocalRightwards ProcExpr [pat] $ \ [pat'] -> rnCmdTop body `thenM` \ (body',fvBody) -> - returnM (HsProc pat' body', fvBody) + return (HsProc pat' body', fvBody) rnExpr (HsArrApp arrow arg _ ho rtl) = select_arrow_scope (rnLExpr arrow) `thenM` \ (arrow',fvArrow) -> rnLExpr arg `thenM` \ (arg',fvArg) -> - returnM (HsArrApp arrow' arg' placeHolderType ho rtl, + return (HsArrApp arrow' arg' placeHolderType ho rtl, fvArrow `plusFV` fvArg) where select_arrow_scope tc = case ho of @@ -331,18 +335,34 @@ rnExpr (HsArrForm op (Just _) [arg1, arg2]) lookupFixityRn op_name `thenM` \ fixity -> mkOpFormRn arg1' op' fixity arg2' `thenM` \ final_e -> - returnM (final_e, + return (final_e, fv_arg1 `plusFV` fv_op `plusFV` fv_arg2) rnExpr (HsArrForm op fixity cmds) = escapeArrowScope (rnLExpr op) `thenM` \ (op',fvOp) -> rnCmdArgs cmds `thenM` \ (cmds',fvCmds) -> - returnM (HsArrForm op' fixity cmds', fvOp `plusFV` fvCmds) + return (HsArrForm op' fixity cmds', fvOp `plusFV` fvCmds) rnExpr other = pprPanic "rnExpr: unexpected expression" (ppr other) -- HsWrap -\end{code} +---------------------- +-- See Note [Parsing sections] in Parser.y.pp +rnSection :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars) +rnSection section@(SectionR op expr) + = do { (op', fvs_op) <- rnLExpr op + ; (expr', fvs_expr) <- rnLExpr expr + ; checkSectionPrec InfixR section op' expr' + ; return (SectionR op' expr', fvs_op `plusFV` fvs_expr) } + +rnSection section@(SectionL expr op) + = do { (expr', fvs_expr) <- rnLExpr expr + ; (op', fvs_op) <- rnLExpr op + ; checkSectionPrec InfixL section op' expr' + ; return (SectionL expr' op', fvs_op `plusFV` fvs_expr) } + +rnSection other = pprPanic "rnSection" (ppr other) +\end{code} %************************************************************************ %* * @@ -352,11 +372,11 @@ rnExpr other = pprPanic "rnExpr: unexpected expression" (ppr other) \begin{code} rnCmdArgs :: [LHsCmdTop RdrName] -> RnM ([LHsCmdTop Name], FreeVars) -rnCmdArgs [] = returnM ([], emptyFVs) +rnCmdArgs [] = return ([], emptyFVs) rnCmdArgs (arg:args) = rnCmdTop arg `thenM` \ (arg',fvArg) -> rnCmdArgs args `thenM` \ (args',fvArgs) -> - returnM (arg':args', fvArg `plusFV` fvArgs) + return (arg':args', fvArg `plusFV` fvArgs) rnCmdTop :: LHsCmdTop RdrName -> RnM (LHsCmdTop Name, FreeVars) rnCmdTop = wrapLocFstM rnCmdTop' @@ -370,7 +390,7 @@ rnCmdTop = wrapLocFstM rnCmdTop' -- Generate the rebindable syntax for the monad lookupSyntaxTable cmd_names `thenM` \ (cmd_names', cmd_fvs) -> - returnM (HsCmdTop cmd' [] placeHolderType cmd_names', + return (HsCmdTop cmd' [] placeHolderType cmd_names', fvCmd `plusFV` cmd_fvs) --------------------------------------------------- @@ -521,23 +541,23 @@ methodNamesStmt (GroupStmt _ _) = emptyFVs rnArithSeq :: ArithSeqInfo RdrName -> RnM (ArithSeqInfo Name, FreeVars) rnArithSeq (From expr) = rnLExpr expr `thenM` \ (expr', fvExpr) -> - returnM (From expr', fvExpr) + return (From expr', fvExpr) rnArithSeq (FromThen expr1 expr2) = rnLExpr expr1 `thenM` \ (expr1', fvExpr1) -> rnLExpr expr2 `thenM` \ (expr2', fvExpr2) -> - returnM (FromThen expr1' expr2', fvExpr1 `plusFV` fvExpr2) + return (FromThen expr1' expr2', fvExpr1 `plusFV` fvExpr2) rnArithSeq (FromTo expr1 expr2) = rnLExpr expr1 `thenM` \ (expr1', fvExpr1) -> rnLExpr expr2 `thenM` \ (expr2', fvExpr2) -> - returnM (FromTo expr1' expr2', fvExpr1 `plusFV` fvExpr2) + return (FromTo expr1' expr2', fvExpr1 `plusFV` fvExpr2) rnArithSeq (FromThenTo expr1 expr2 expr3) = rnLExpr expr1 `thenM` \ (expr1', fvExpr1) -> rnLExpr expr2 `thenM` \ (expr2', fvExpr2) -> rnLExpr expr3 `thenM` \ (expr3', fvExpr3) -> - returnM (FromThenTo expr1' expr2' expr3', + return (FromThenTo expr1' expr2' expr3', plusFVs [fvExpr1, fvExpr2, fvExpr3]) \end{code} @@ -552,18 +572,16 @@ rnBracket :: HsBracket RdrName -> RnM (HsBracket Name, FreeVars) rnBracket (VarBr n) = do { name <- lookupOccRn n ; this_mod <- getModule ; checkM (nameIsLocalOrFrom this_mod name) $ -- Reason: deprecation checking asumes the - do { loadInterfaceForName msg name -- home interface is loaded, and this is the + do { _ <- loadInterfaceForName msg name -- home interface is loaded, and this is the ; return () } -- only way that is going to happen - ; returnM (VarBr name, unitFV name) } + ; return (VarBr name, unitFV name) } where msg = ptext (sLit "Need interface for Template Haskell quoted Name") rnBracket (ExpBr e) = do { (e', fvs) <- rnLExpr e ; return (ExpBr e', fvs) } -rnBracket (PatBr _) = do { addErr (ptext (sLit "Tempate Haskell pattern brackets are not supported yet")); - failM } - +rnBracket (PatBr _) = failWith (ptext (sLit "Tempate Haskell pattern brackets are not supported yet")) rnBracket (TypBr t) = do { (t', fvs) <- rnHsTypeFVs doc t ; return (TypBr t', fvs) } where @@ -571,31 +589,15 @@ rnBracket (TypBr t) = do { (t', fvs) <- rnHsTypeFVs doc t rnBracket (DecBr group) = do { gbl_env <- getGblEnv - ; let new_gbl_env = gbl_env { -- Set the module to thFAKE. The top-level names from the bracketed - -- declarations will go into the name cache, and we don't want them to - -- confuse the Names for the current module. - -- By using a pretend module, thFAKE, we keep them safely out of the way. - tcg_mod = thFAKE, - - -- The emptyDUs is so that we just collect uses for this group alone - -- in the call to rnSrcDecls below - tcg_dus = emptyDUs } - ; setGblEnv new_gbl_env $ do { - - -- In this situation we want to *shadow* top-level bindings. - -- foo = 1 - -- bar = [d| foo = 1 |] - -- If we don't shadow, we'll get an ambiguity complaint when we do - -- a lookupTopBndrRn (which uses lookupGreLocalRn) on the binder of the 'foo' - -- - -- Furthermore, arguably if the splice does define foo, that should hide - -- any foo's further out - -- - -- The shadowing is acheived by calling rnSrcDecls with True as the shadowing flag - ; (tcg_env, group') <- rnSrcDecls True group + ; let new_gbl_env = gbl_env { tcg_dus = emptyDUs } + -- The emptyDUs is so that we just collect uses for this + -- group alone in the call to rnSrcDecls below + ; (tcg_env, group') <- setGblEnv new_gbl_env $ + setStage thRnBrack $ + rnSrcDecls group -- Discard the tcg_env; it contains only extra info about fixity - ; return (DecBr group', allUses (tcg_dus tcg_env)) } } + ; return (DecBr group', allUses (tcg_dus tcg_env)) } \end{code} %************************************************************************ @@ -795,7 +797,7 @@ rnParallelStmts ctxt segs thing_inside = do let (bndrs', dups) = removeDups cmpByOcc bndrs inner_env = extendLocalRdrEnv orig_lcl_env bndrs' - mappM dupErr dups + mapM_ dupErr dups (thing, fvs) <- setLocalRdrEnv inner_env thing_inside return (([], thing), fvs) @@ -927,8 +929,7 @@ rn_rec_stmt_lhs fix_env (L loc (BindStmt pat expr a b)) fv_pat)] rn_rec_stmt_lhs _ (L _ (LetStmt binds@(HsIPBinds _))) - = do { addErr (badIpBinds (ptext (sLit "an mdo expression")) binds) - ; failM } + = failWith (badIpBinds (ptext (sLit "an mdo expression")) binds) rn_rec_stmt_lhs fix_env (L loc (LetStmt (HsValBinds binds))) = do binds' <- rnValBindsLHS fix_env binds @@ -963,7 +964,7 @@ rn_rec_stmts_lhs fix_env stmts = -- don't bind all of the variables from the Stmt at once -- with bindLocatedLocals. checkDupRdrNames doc boundNames - mappM (rn_rec_stmt_lhs fix_env) stmts `thenM` \ ls -> returnM (concat ls) + mapM (rn_rec_stmt_lhs fix_env) stmts `thenM` \ ls -> return (concat ls) -- right-hand-sides @@ -975,7 +976,7 @@ rn_rec_stmt :: [Name] -> LStmtLR Name RdrName -> FreeVars -> RnM [Segment (LStmt rn_rec_stmt _ (L loc (ExprStmt expr _ _)) _ = rnLExpr expr `thenM` \ (expr', fvs) -> lookupSyntaxName thenMName `thenM` \ (then_op, fvs1) -> - returnM [(emptyNameSet, fvs `plusFV` fvs1, emptyNameSet, + return [(emptyNameSet, fvs `plusFV` fvs1, emptyNameSet, L loc (ExprStmt expr' then_op placeHolderType))] rn_rec_stmt _ (L loc (BindStmt pat' expr _ _)) fv_pat @@ -986,18 +987,17 @@ rn_rec_stmt _ (L loc (BindStmt pat' expr _ _)) fv_pat bndrs = mkNameSet (collectPatBinders pat') fvs = fv_expr `plusFV` fv_pat `plusFV` fvs1 `plusFV` fvs2 in - returnM [(bndrs, fvs, bndrs `intersectNameSet` fvs, + return [(bndrs, fvs, bndrs `intersectNameSet` fvs, L loc (BindStmt pat' expr' bind_op fail_op))] rn_rec_stmt _ (L _ (LetStmt binds@(HsIPBinds _))) _ - = do { addErr (badIpBinds (ptext (sLit "an mdo expression")) binds) - ; failM } + = failWith (badIpBinds (ptext (sLit "an mdo expression")) binds) rn_rec_stmt all_bndrs (L loc (LetStmt (HsValBinds binds'))) _ = do (binds', du_binds) <- -- fixities and unused are handled above in rn_rec_stmts_and_then - rnValBindsRHS all_bndrs binds' - returnM [(duDefs du_binds, duUses du_binds, + rnValBindsRHS (mkNameSet all_bndrs) binds' + return [(duDefs du_binds, duUses du_binds, emptyNameSet, L loc (LetStmt (HsValBinds binds')))] -- no RecStmt case becuase they get flattened above when doing the LHSes @@ -1017,8 +1017,8 @@ rn_rec_stmt _ (L _ (LetStmt EmptyLocalBinds)) _ = panic "rn_rec_stmt: LetStmt EmptyLocalBinds" rn_rec_stmts :: [Name] -> [(LStmtLR Name RdrName, FreeVars)] -> RnM [Segment (LStmt Name)] -rn_rec_stmts bndrs stmts = mappM (uncurry (rn_rec_stmt bndrs)) stmts `thenM` \ segs_s -> - returnM (concat segs_s) +rn_rec_stmts bndrs stmts = mapM (uncurry (rn_rec_stmt bndrs)) stmts `thenM` \ segs_s -> + return (concat segs_s) --------------------------------------------- addFwdRefs :: [Segment a] -> [Segment a] @@ -1129,19 +1129,26 @@ segsToStmts ((defs, uses, fwds, ss) : segs) fvs_later \begin{code} srcSpanPrimLit :: SrcSpan -> HsExpr Name -srcSpanPrimLit span = HsLit (HsStringPrim (mkFastString (showSDoc (ppr span)))) +srcSpanPrimLit span = HsLit (HsStringPrim (mkFastString (showSDocOneLine (ppr span)))) -mkAssertErrorExpr :: RnM (HsExpr Name, FreeVars) +mkAssertErrorExpr :: RnM (HsExpr Name) -- Return an expression for (assertError "Foo.hs:27") mkAssertErrorExpr = getSrcSpanM `thenM` \ sloc -> - let - expr = HsApp (L sloc (HsVar assertErrorName)) - (L sloc (srcSpanPrimLit sloc)) - in - returnM (expr, emptyFVs) + return (HsApp (L sloc (HsVar assertErrorName)) + (L sloc (srcSpanPrimLit sloc))) \end{code} +Note [Adding the implicit parameter to 'assert'] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +The renamer transforms (assert e1 e2) to (assert "Foo.hs:27" e1 e2). +By doing this in the renamer we allow the typechecker to just see the +expanded application and do the right thing. But it's not really +the Right Thing because there's no way to "undo" if you want to see +the original source code. We'll have fix this in due course, when +we care more about being able to reconstruct the exact original +program. + %************************************************************************ %* * \subsubsection{Errors} @@ -1190,8 +1197,21 @@ checkTransformStmt (TransformStmtCtxt ctxt) = checkTransformStmt ctxt -- Ok to n checkTransformStmt ctxt = addErr msg where msg = ptext (sLit "Illegal transform or grouping in") <+> pprStmtContext ctxt - + --------- +checkTupleSection :: [HsTupArg RdrName] -> RnM () +checkTupleSection args + = do { tuple_section <- doptM Opt_TupleSections + ; checkErr (all tupArgPresent args || tuple_section) msg } + where + msg = ptext (sLit "Illegal tuple section: use -XTupleSections") + +--------- +sectionErr :: HsExpr RdrName -> SDoc +sectionErr expr + = hang (ptext (sLit "A section must be enclosed in parentheses")) + 2 (ptext (sLit "thus:") <+> (parens (ppr expr))) + patSynErr :: HsExpr RdrName -> RnM (HsExpr Name, FreeVars) patSynErr e = do { addErr (sep [ptext (sLit "Pattern syntax in expression context:"), nest 4 (ppr e)])