X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Frename%2FRnExpr.lhs;h=4ce71826f66ee8bfb10376f02965c5facbc9449c;hp=942ac2d0fee9ec73c8be9ef65f394790c8639113;hb=f04dead93a15af1cb818172f207b8a81d2c81298;hpb=83256c875683894a93cf4468947ccf11c65577ca diff --git a/compiler/rename/RnExpr.lhs b/compiler/rename/RnExpr.lhs index 942ac2d..4ce7182 100644 --- a/compiler/rename/RnExpr.lhs +++ b/compiler/rename/RnExpr.lhs @@ -20,35 +20,32 @@ 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, - loopAName, choiceAName, appAName, arrAName, composeAName, firstAName, - negateName, thenMName, bindMName, failMName, groupWithName ) +import PrelNames import Name import NameSet import RdrName import LoadIface ( loadInterfaceForName ) import UniqSet -import List ( nub ) +import Data.List import Util ( isSingleton ) import ListSetOps ( removeDups ) import Maybes ( expectJust ) import Outputable import SrcLoc import FastString - -import List ( unzip4 ) import Control.Monad \end{code} @@ -60,15 +57,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 +69,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 +79,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. @@ -119,7 +107,7 @@ rnExpr (HsVar v) rnExpr (HsIPVar v) = newIPNameRn v `thenM` \ name -> - returnM (HsIPVar name, emptyFVs) + return (HsIPVar name, emptyFVs) rnExpr (HsLit lit@(HsString s)) = do { @@ -128,21 +116,21 @@ 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) + return (HsApp fun' arg', fvFun `plusFV` fvArg) rnExpr (OpApp e1 (L op_loc (HsVar op_rdr)) _ e2) = do { (e1', fv_e1) <- rnLExpr e1 @@ -164,7 +152,7 @@ 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) + return (final_e, fv_e `plusFV` fv_neg) ------------------------------------------ -- Template Haskell extensions @@ -173,11 +161,11 @@ rnExpr (NegApp e _) 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,7 +174,7 @@ 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 */ --------------------------------------------- @@ -212,28 +200,28 @@ rnExpr expr@(SectionR {}) --------------------------------------------- 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 $ @@ -242,26 +230,30 @@ 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 - ; (rbinds', fvRbinds) <- rnHsRecFields_Con conname rnLExpr rbinds + ; (rbinds', fvRbinds) <- rnHsRecBinds (HsRecFieldCon (unLoc conname)) rbinds ; return (RecordCon conname noPostTcExpr rbinds', fvRbinds `addOneFV` unLoc conname) } rnExpr (RecordUpd expr rbinds _ _ _) = do { (expr', fvExpr) <- rnLExpr expr - ; (rbinds', fvRbinds) <- rnHsRecFields_Update rnLExpr rbinds + ; (rbinds', fvRbinds) <- rnHsRecBinds HsRecFieldUpd rbinds ; return (RecordUpd expr' rbinds' [] [] [], fvExpr `plusFV` fvRbinds) } @@ -277,21 +269,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. @@ -314,14 +306,14 @@ rnExpr e@(ELazyPat {}) = patSynErr e \begin{code} rnExpr (HsProc pat body) = newArrowScope $ - rnPatsAndThen_LocalRightwards ProcExpr [pat] $ \ [pat'] -> + rnPats 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 @@ -340,13 +332,13 @@ 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 @@ -371,17 +363,37 @@ rnSection other = pprPanic "rnSection" (ppr other) %************************************************************************ %* * + Records +%* * +%************************************************************************ + +\begin{code} +rnHsRecBinds :: HsRecFieldContext -> HsRecordBinds RdrName + -> RnM (HsRecordBinds Name, FreeVars) +rnHsRecBinds ctxt rec_binds@(HsRecFields { rec_dotdot = dd }) + = do { (flds, fvs) <- rnHsRecFields1 ctxt HsVar rec_binds + ; (flds', fvss) <- mapAndUnzipM rn_field flds + ; return (HsRecFields { rec_flds = flds', rec_dotdot = dd }, + fvs `plusFV` plusFVs fvss) } + where + rn_field fld = do { (arg', fvs) <- rnLExpr (hsRecFieldArg fld) + ; return (fld { hsRecFieldArg = arg' }, fvs) } +\end{code} + + +%************************************************************************ +%* * Arrow commands %* * %************************************************************************ \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' @@ -395,7 +407,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) --------------------------------------------------- @@ -440,8 +452,8 @@ convertOpFormsStmt (BindStmt pat cmd _ _) = BindStmt pat (convertOpFormsLCmd cmd) noSyntaxExpr noSyntaxExpr convertOpFormsStmt (ExprStmt cmd _ _) = ExprStmt (convertOpFormsLCmd cmd) noSyntaxExpr placeHolderType -convertOpFormsStmt (RecStmt stmts lvs rvs es binds) - = RecStmt (map (fmap convertOpFormsStmt) stmts) lvs rvs es binds +convertOpFormsStmt stmt@(RecStmt { recS_stmts = stmts }) + = stmt { recS_stmts = map (fmap convertOpFormsStmt) stmts } convertOpFormsStmt stmt = stmt convertOpFormsMatch :: MatchGroup id -> MatchGroup id @@ -523,14 +535,13 @@ methodNamesLStmt :: Located (StmtLR Name Name) -> FreeVars methodNamesLStmt = methodNamesStmt . unLoc methodNamesStmt :: StmtLR Name Name -> FreeVars -methodNamesStmt (ExprStmt cmd _ _) = methodNamesLCmd cmd -methodNamesStmt (BindStmt _ cmd _ _) = methodNamesLCmd cmd -methodNamesStmt (RecStmt stmts _ _ _ _) - = methodNamesStmts stmts `addOneFV` loopAName -methodNamesStmt (LetStmt _) = emptyFVs -methodNamesStmt (ParStmt _) = emptyFVs -methodNamesStmt (TransformStmt _ _ _) = emptyFVs -methodNamesStmt (GroupStmt _ _) = emptyFVs +methodNamesStmt (ExprStmt cmd _ _) = methodNamesLCmd cmd +methodNamesStmt (BindStmt _ cmd _ _) = methodNamesLCmd cmd +methodNamesStmt (RecStmt { recS_stmts = stmts }) = methodNamesStmts stmts `addOneFV` loopAName +methodNamesStmt (LetStmt _) = emptyFVs +methodNamesStmt (ParStmt _) = emptyFVs +methodNamesStmt (TransformStmt _ _ _) = emptyFVs +methodNamesStmt (GroupStmt _ _) = emptyFVs -- ParStmt, TransformStmt and GroupStmt can't occur in commands, but it's not convenient to error -- here so we just do what's convenient \end{code} @@ -546,23 +557,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} @@ -576,10 +587,10 @@ rnArithSeq (FromThenTo expr1 expr2 expr3) 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 + ; unless (nameIsLocalOrFrom this_mod name) $ -- Reason: deprecation checking asumes 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") @@ -594,31 +605,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} %************************************************************************ @@ -638,67 +633,95 @@ rnStmts ctxt = rnNormalStmts ctxt rnNormalStmts :: HsStmtContext Name -> [LStmt RdrName] -> RnM (thing, FreeVars) -> RnM (([LStmt Name], thing), FreeVars) --- Used for cases *other* than recursive mdo --- Implements nested scopes - rnNormalStmts _ [] thing_inside = do { (thing, fvs) <- thing_inside ; return (([],thing), fvs) } -rnNormalStmts ctxt (L loc stmt : stmts) thing_inside - = do { ((stmt', (stmts', thing)), fvs) <- rnStmt ctxt stmt $ - rnNormalStmts ctxt stmts thing_inside - ; return (((L loc stmt' : stmts'), thing), fvs) } +rnNormalStmts ctxt (stmt@(L loc _) : stmts) thing_inside + = do { ((stmts1, (stmts2, thing)), fvs) + <- setSrcSpan loc $ + rnStmt ctxt stmt $ + rnNormalStmts ctxt stmts thing_inside + ; return (((stmts1 ++ stmts2), thing), fvs) } -rnStmt :: HsStmtContext Name -> Stmt RdrName +rnStmt :: HsStmtContext Name -> LStmt RdrName -> RnM (thing, FreeVars) - -> RnM ((Stmt Name, thing), FreeVars) + -> RnM (([LStmt Name], thing), FreeVars) -rnStmt _ (ExprStmt expr _ _) thing_inside +rnStmt _ (L loc (ExprStmt expr _ _)) thing_inside = do { (expr', fv_expr) <- rnLExpr expr ; (then_op, fvs1) <- lookupSyntaxName thenMName ; (thing, fvs2) <- thing_inside - ; return ((ExprStmt expr' then_op placeHolderType, thing), + ; return (([L loc (ExprStmt expr' then_op placeHolderType)], thing), fv_expr `plusFV` fvs1 `plusFV` fvs2) } -rnStmt ctxt (BindStmt pat expr _ _) thing_inside +rnStmt ctxt (L loc (BindStmt pat expr _ _)) thing_inside = do { (expr', fv_expr) <- rnLExpr expr -- The binders do not scope over the expression ; (bind_op, fvs1) <- lookupSyntaxName bindMName ; (fail_op, fvs2) <- lookupSyntaxName failMName - ; rnPatsAndThen_LocalRightwards (StmtCtxt ctxt) [pat] $ \ [pat'] -> do + ; rnPats (StmtCtxt ctxt) [pat] $ \ [pat'] -> do { (thing, fvs3) <- thing_inside - ; return ((BindStmt pat' expr' bind_op fail_op, thing), + ; return (([L loc (BindStmt pat' expr' bind_op fail_op)], thing), fv_expr `plusFV` fvs1 `plusFV` fvs2 `plusFV` fvs3) }} -- fv_expr shouldn't really be filtered by the rnPatsAndThen -- but it does not matter because the names are unique -rnStmt ctxt (LetStmt binds) thing_inside +rnStmt ctxt (L loc (LetStmt binds)) thing_inside = do { checkLetStmt ctxt binds ; rnLocalBindsAndThen binds $ \binds' -> do { (thing, fvs) <- thing_inside - ; return ((LetStmt binds', thing), fvs) } } + ; return (([L loc (LetStmt binds')], thing), fvs) } } -rnStmt ctxt (RecStmt rec_stmts _ _ _ _) thing_inside +rnStmt ctxt (L _ (RecStmt { recS_stmts = rec_stmts })) thing_inside = do { checkRecStmt ctxt - ; rn_rec_stmts_and_then rec_stmts $ \ segs -> do - { (thing, fvs) <- thing_inside + + -- Step1: Bring all the binders of the mdo into scope + -- (Remember that this also removes the binders from the + -- finally-returned free-vars.) + -- And rename each individual stmt, making a + -- singleton segment. At this stage the FwdRefs field + -- isn't finished: it's empty for all except a BindStmt + -- for which it's the fwd refs within the bind itself + -- (This set may not be empty, because we're in a recursive + -- context.) + ; rn_rec_stmts_and_then rec_stmts $ \ segs -> do + + { (thing, fvs_later) <- thing_inside + ; (return_op, fvs1) <- lookupSyntaxName returnMName + ; (mfix_op, fvs2) <- lookupSyntaxName mfixName + ; (bind_op, fvs3) <- lookupSyntaxName bindMName ; let + -- Step 2: Fill in the fwd refs. + -- The segments are all singletons, but their fwd-ref + -- field mentions all the things used by the segment + -- that are bound after their use segs_w_fwd_refs = addFwdRefs segs - (ds, us, fs, rec_stmts') = unzip4 segs_w_fwd_refs - later_vars = nameSetToList (plusFVs ds `intersectNameSet` fvs) - fwd_vars = nameSetToList (plusFVs fs) - uses = plusFVs us - rec_stmt = RecStmt rec_stmts' later_vars fwd_vars [] emptyLHsBinds - ; return ((rec_stmt, thing), uses `plusFV` fvs) } } - -rnStmt ctxt (ParStmt segs) thing_inside + + -- Step 3: Group together the segments to make bigger segments + -- Invariant: in the result, no segment uses a variable + -- bound in a later segment + grouped_segs = glomSegments segs_w_fwd_refs + + -- Step 4: Turn the segments into Stmts + -- Use RecStmt when and only when there are fwd refs + -- Also gather up the uses from the end towards the + -- start, so we can tell the RecStmt which things are + -- used 'after' the RecStmt + empty_rec_stmt = emptyRecStmt { recS_ret_fn = return_op + , recS_mfix_fn = mfix_op + , recS_bind_fn = bind_op } + (rec_stmts', fvs) = segsToStmts empty_rec_stmt grouped_segs fvs_later + + ; return ((rec_stmts', thing), fvs `plusFV` fvs1 `plusFV` fvs2 `plusFV` fvs3) } } + +rnStmt ctxt (L loc (ParStmt segs)) thing_inside = do { checkParStmt ctxt ; ((segs', thing), fvs) <- rnParallelStmts (ParStmtCtxt ctxt) segs thing_inside - ; return ((ParStmt segs', thing), fvs) } + ; return (([L loc (ParStmt segs')], thing), fvs) } -rnStmt ctxt (TransformStmt (stmts, _) usingExpr maybeByExpr) thing_inside = do +rnStmt ctxt (L loc (TransformStmt (stmts, _) usingExpr maybeByExpr)) thing_inside = do checkTransformStmt ctxt (usingExpr', fv_usingExpr) <- rnLExpr usingExpr @@ -709,14 +732,15 @@ rnStmt ctxt (TransformStmt (stmts, _) usingExpr maybeByExpr) thing_inside = do return ((maybeByExpr', thing), fv_maybeByExpr `plusFV` fv_thing) - return ((TransformStmt (stmts', binders) usingExpr' maybeByExpr', thing), fv_usingExpr `plusFV` fvs) + return (([L loc (TransformStmt (stmts', binders) usingExpr' maybeByExpr')], thing), + fv_usingExpr `plusFV` fvs) where rnMaybeLExpr Nothing = return (Nothing, emptyFVs) rnMaybeLExpr (Just expr) = do (expr', fv_expr) <- rnLExpr expr return (Just expr', fv_expr) -rnStmt ctxt (GroupStmt (stmts, _) groupByClause) thing_inside = do +rnStmt ctxt (L loc (GroupStmt (stmts, _) groupByClause)) thing_inside = do checkTransformStmt ctxt -- We must rename the using expression in the context before the transform is begun @@ -773,7 +797,7 @@ rnStmt ctxt (GroupStmt (stmts, _) groupByClause) thing_inside = do return ((groupByClause', usedBinderMap, thing), fv_groupByClause `plusFV` real_fv_thing) traceRn (text "rnStmt: implicitly rebound these used binders:" <+> ppr usedBinderMap) - return ((GroupStmt (stmts', usedBinderMap) groupByClause', thing), fvs) + return (([L loc (GroupStmt (stmts', usedBinderMap) groupByClause')], thing), fvs) rnNormalStmtsAndFindUsedBinders :: HsStmtContext Name -> [LStmt RdrName] @@ -816,9 +840,9 @@ rnParallelStmts ctxt segs thing_inside = do where go orig_lcl_env bndrs [] = do let (bndrs', dups) = removeDups cmpByOcc bndrs - inner_env = extendLocalRdrEnv orig_lcl_env bndrs' + inner_env = extendLocalRdrEnvList orig_lcl_env bndrs' - mappM dupErr dups + mapM_ dupErr dups (thing, fvs) <- setLocalRdrEnv inner_env thing_inside return (([], thing), fvs) @@ -860,39 +884,12 @@ rnMDoStmts :: [LStmt RdrName] -> RnM (thing, FreeVars) -> RnM (([LStmt Name], thing), FreeVars) rnMDoStmts stmts thing_inside - = -- Step1: Bring all the binders of the mdo into scope - -- (Remember that this also removes the binders from the - -- finally-returned free-vars.) - -- And rename each individual stmt, making a - -- singleton segment. At this stage the FwdRefs field - -- isn't finished: it's empty for all except a BindStmt - -- for which it's the fwd refs within the bind itself - -- (This set may not be empty, because we're in a recursive - -- context.) - rn_rec_stmts_and_then stmts $ \ segs -> do { - - ; (thing, fvs_later) <- thing_inside - - ; let - -- Step 2: Fill in the fwd refs. - -- The segments are all singletons, but their fwd-ref - -- field mentions all the things used by the segment - -- that are bound after their use - segs_w_fwd_refs = addFwdRefs segs - - -- Step 3: Group together the segments to make bigger segments - -- Invariant: in the result, no segment uses a variable - -- bound in a later segment + = rn_rec_stmts_and_then stmts $ \ segs -> do + { (thing, fvs_later) <- thing_inside + ; let segs_w_fwd_refs = addFwdRefs segs grouped_segs = glomSegments segs_w_fwd_refs - - -- Step 4: Turn the segments into Stmts - -- Use RecStmt when and only when there are fwd refs - -- Also gather up the uses from the end towards the - -- start, so we can tell the RecStmt which things are - -- used 'after' the RecStmt - (stmts', fvs) = segsToStmts grouped_segs fvs_later - - ; return ((stmts', thing), fvs) } + (stmts', fvs) = segsToStmts emptyRecStmt grouped_segs fvs_later + ; return ((stmts', thing), fvs) } --------------------------------------------- @@ -959,7 +956,8 @@ rn_rec_stmt_lhs fix_env (L loc (LetStmt (HsValBinds binds))) emptyFVs )] -rn_rec_stmt_lhs fix_env (L _ (RecStmt stmts _ _ _ _)) -- Flatten Rec inside Rec +-- XXX Do we need to do something with the return and mfix names? +rn_rec_stmt_lhs fix_env (L _ (RecStmt { recS_stmts = stmts })) -- Flatten Rec inside Rec = rn_rec_stmts_lhs fix_env stmts rn_rec_stmt_lhs _ stmt@(L _ (ParStmt _)) -- Syntactically illegal in mdo @@ -985,7 +983,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 @@ -997,7 +995,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 @@ -1008,7 +1006,7 @@ 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 _))) _ @@ -1017,29 +1015,29 @@ rn_rec_stmt _ (L _ (LetStmt binds@(HsIPBinds _))) _ 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 -rn_rec_stmt _ stmt@(L _ (RecStmt _ _ _ _ _)) _ +rn_rec_stmt _ stmt@(L _ (RecStmt {})) _ = pprPanic "rn_rec_stmt: RecStmt" (ppr stmt) -rn_rec_stmt _ stmt@(L _ (ParStmt _)) _ -- Syntactically illegal in mdo +rn_rec_stmt _ stmt@(L _ (ParStmt {})) _ -- Syntactically illegal in mdo = pprPanic "rn_rec_stmt: ParStmt" (ppr stmt) -rn_rec_stmt _ stmt@(L _ (TransformStmt _ _ _)) _ -- Syntactically illegal in mdo +rn_rec_stmt _ stmt@(L _ (TransformStmt {})) _ -- Syntactically illegal in mdo = pprPanic "rn_rec_stmt: TransformStmt" (ppr stmt) -rn_rec_stmt _ stmt@(L _ (GroupStmt _ _)) _ -- Syntactically illegal in mdo +rn_rec_stmt _ stmt@(L _ (GroupStmt {})) _ -- Syntactically illegal in mdo = pprPanic "rn_rec_stmt: GroupStmt" (ppr stmt) 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] @@ -1122,23 +1120,24 @@ glomSegments ((defs,uses,fwds,stmt) : segs) ---------------------------------------------------- -segsToStmts :: [Segment [LStmt Name]] +segsToStmts :: Stmt Name -- A RecStmt with the SyntaxOps filled in + -> [Segment [LStmt Name]] -> FreeVars -- Free vars used 'later' -> ([LStmt Name], FreeVars) -segsToStmts [] fvs_later = ([], fvs_later) -segsToStmts ((defs, uses, fwds, ss) : segs) fvs_later +segsToStmts _ [] fvs_later = ([], fvs_later) +segsToStmts empty_rec_stmt ((defs, uses, fwds, ss) : segs) fvs_later = ASSERT( not (null ss) ) (new_stmt : later_stmts, later_uses `plusFV` uses) where - (later_stmts, later_uses) = segsToStmts segs fvs_later + (later_stmts, later_uses) = segsToStmts empty_rec_stmt segs fvs_later new_stmt | non_rec = head ss - | otherwise = L (getLoc (head ss)) $ - RecStmt ss (nameSetToList used_later) (nameSetToList fwds) - [] emptyLHsBinds - where - non_rec = isSingleton ss && isEmptyNameSet fwds - used_later = defs `intersectNameSet` later_uses + | otherwise = L (getLoc (head ss)) rec_stmt + rec_stmt = empty_rec_stmt { recS_stmts = ss + , recS_later_ids = nameSetToList used_later + , recS_rec_ids = nameSetToList fwds } + non_rec = isSingleton ss && isEmptyNameSet fwds + used_later = defs `intersectNameSet` later_uses -- The ones needed after the RecStmt \end{code} @@ -1150,7 +1149,7 @@ 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) -- Return an expression for (assertError "Foo.hs:27") @@ -1189,10 +1188,7 @@ checkLetStmt _ctxt _binds = return () --------- checkRecStmt :: HsStmtContext Name -> RnM () checkRecStmt (MDoExpr {}) = return () -- Recursive stmt ok in 'mdo' -checkRecStmt (DoExpr {}) = return () -- ..and in 'do' but only because of arrows: - -- proc x -> do { ...rec... } - -- We don't have enough context to distinguish this situation here - -- so we leave it to the type checker +checkRecStmt (DoExpr {}) = return () -- and in 'do' checkRecStmt ctxt = addErr msg where msg = ptext (sLit "Illegal 'rec' stmt in") <+> pprStmtContext ctxt @@ -1218,7 +1214,15 @@ 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