X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Frename%2FRnExpr.lhs;h=a128c3561f4adce8928604f746a442eb90ec5cf7;hb=5d3051c66796dcf884b052f9e4afc3ed19b9f514;hp=9329f6a234a9f466189489b3a28f467dfffe5f66;hpb=23f40f0e9be6d4aa5cf9ea31d73f4013f8e7b4bd;p=ghc-hetmet.git diff --git a/ghc/compiler/rename/RnExpr.lhs b/ghc/compiler/rename/RnExpr.lhs index 9329f6a..a128c35 100644 --- a/ghc/compiler/rename/RnExpr.lhs +++ b/ghc/compiler/rename/RnExpr.lhs @@ -11,124 +11,46 @@ free variables. \begin{code} module RnExpr ( - rnMatchGroup, rnMatch, rnGRHSs, rnLExpr, rnExpr, rnStmts, - checkPrecMatch, checkTH + rnLExpr, rnExpr, rnStmts ) where #include "HsVersions.h" -import {-# SOURCE #-} RnSource ( rnSrcDecls, rnBindGroupsAndThen, rnBindGroups, rnSplice ) - --- RnSource imports RnBinds.rnTopMonoBinds, RnExpr.rnExpr --- RnBinds imports RnExpr.rnMatch, etc --- RnExpr imports [boot] RnSource.rnSrcDecls, RnSource.rnBinds - +import RnSource ( rnSrcDecls, rnSplice, checkTH ) +import RnBinds ( rnLocalBindsAndThen, rnValBinds, + rnMatchGroup, trimWith ) import HsSyn import RnHsSyn import TcRnMonad import RnEnv import OccName ( plusOccEnv ) -import RnNames ( importsFromLocalDecls ) +import RnNames ( getLocalDeclBinders, extendRdrEnvRn ) import RnTypes ( rnHsTypeFVs, rnLPat, rnOverLit, rnPatsAndThen, rnLit, - dupFieldErr, precParseErr, sectionPrecErr, patSigErr, - checkTupSize ) -import CmdLineOpts ( DynFlag(..) ) -import BasicTypes ( Fixity(..), FixityDirection(..), negateFixity, compareFixity ) -import PrelNames ( hasKey, assertIdKey, assertErrorName, + mkOpFormRn, mkOpAppRn, mkNegAppRn, checkSectionPrec, + dupFieldErr, checkTupSize ) +import DynFlags ( DynFlag(..) ) +import BasicTypes ( FixityDirection(..) ) +import PrelNames ( thFAKE, hasKey, assertIdKey, assertErrorName, loopAName, choiceAName, appAName, arrAName, composeAName, firstAName, - negateName, monadNames, mfixName ) -import Name ( Name, nameOccName ) + negateName, thenMName, bindMName, failMName ) +import Name ( Name, nameOccName, nameIsLocalOrFrom ) import NameSet -import RdrName ( RdrName ) -import UnicodeUtil ( stringToUtf8 ) +import RdrName ( RdrName, emptyGlobalRdrEnv, extendLocalRdrEnv, lookupLocalRdrEnv ) +import LoadIface ( loadHomeInterface ) import UniqFM ( isNullUFM ) import UniqSet ( emptyUniqSet ) +import List ( nub ) import Util ( isSingleton ) import ListSetOps ( removeDups ) +import Maybes ( fromJust ) import Outputable -import SrcLoc ( Located(..), unLoc, getLoc, combineLocs, cmpLocated ) +import SrcLoc ( Located(..), unLoc, getLoc, cmpLocated ) import FastString import List ( unzip4 ) \end{code} -************************************************************************ -* * -\subsection{Match} -* * -************************************************************************ - -\begin{code} -rnMatchGroup :: HsMatchContext Name -> MatchGroup RdrName -> RnM (MatchGroup Name, FreeVars) -rnMatchGroup ctxt (MatchGroup ms _) - = mapFvRn (rnMatch ctxt) ms `thenM` \ (new_ms, ms_fvs) -> - returnM (MatchGroup new_ms placeHolderType, ms_fvs) - -rnMatch :: HsMatchContext Name -> LMatch RdrName -> RnM (LMatch Name, FreeVars) -rnMatch ctxt = wrapLocFstM (rnMatch' ctxt) - -rnMatch' ctxt match@(Match pats maybe_rhs_sig grhss) - = - -- Deal with the rhs type signature - bindPatSigTyVarsFV rhs_sig_tys $ - doptM Opt_GlasgowExts `thenM` \ opt_GlasgowExts -> - (case maybe_rhs_sig of - Nothing -> returnM (Nothing, emptyFVs) - Just ty | opt_GlasgowExts -> rnHsTypeFVs doc_sig ty `thenM` \ (ty', ty_fvs) -> - returnM (Just ty', ty_fvs) - | otherwise -> addLocErr ty patSigErr `thenM_` - returnM (Nothing, emptyFVs) - ) `thenM` \ (maybe_rhs_sig', ty_fvs) -> - - -- Now the main event - rnPatsAndThen ctxt True pats $ \ pats' -> - rnGRHSs ctxt grhss `thenM` \ (grhss', grhss_fvs) -> - - returnM (Match pats' maybe_rhs_sig' grhss', grhss_fvs `plusFV` ty_fvs) - -- The bindPatSigTyVarsFV and rnPatsAndThen will remove the bound FVs - where - rhs_sig_tys = case maybe_rhs_sig of - Nothing -> [] - Just ty -> [ty] - doc_sig = text "In a result type-signature" -\end{code} - - -%************************************************************************ -%* * -\subsubsection{Guarded right-hand sides (GRHSs)} -%* * -%************************************************************************ - -\begin{code} -rnGRHSs :: HsMatchContext Name -> GRHSs RdrName -> RnM (GRHSs Name, FreeVars) - --- gaw 2004 -rnGRHSs ctxt (GRHSs grhss binds) - = rnBindGroupsAndThen binds $ \ binds' -> - mapFvRn (rnGRHS ctxt) grhss `thenM` \ (grhss', fvGRHSs) -> - returnM (GRHSs grhss' binds', fvGRHSs) - -rnGRHS :: HsMatchContext Name -> LGRHS RdrName -> RnM (LGRHS Name, FreeVars) -rnGRHS ctxt = wrapLocFstM (rnGRHS' ctxt) - -rnGRHS' ctxt (GRHS guarded) - = doptM Opt_GlasgowExts `thenM` \ opt_GlasgowExts -> - checkM (opt_GlasgowExts || is_standard_guard guarded) - (addWarn (nonStdGuardErr guarded)) `thenM_` - - rnStmts (PatGuard ctxt) guarded `thenM` \ (guarded', fvs) -> - returnM (GRHS guarded', fvs) - where - -- Standard Haskell 1.4 guards are just a single boolean - -- expression, rather than a list of qualifiers as in the - -- Glasgow extension - is_standard_guard [L _ (ResultStmt _)] = True - is_standard_guard [L _ (ExprStmt _ _), L _ (ResultStmt _)] = True - is_standard_guard other = False -\end{code} - %************************************************************************ %* * \subsubsection{Expressions} @@ -263,28 +185,14 @@ rnExpr (HsCase expr matches) returnM (HsCase new_expr new_matches, e_fvs `plusFV` ms_fvs) rnExpr (HsLet binds expr) - = rnBindGroupsAndThen binds $ \ binds' -> + = rnLocalBindsAndThen binds $ \ binds' -> rnLExpr expr `thenM` \ (expr',fvExpr) -> returnM (HsLet binds' expr', fvExpr) -rnExpr e@(HsDo do_or_lc stmts _ _) - = rnStmts do_or_lc stmts `thenM` \ (stmts', fvs) -> - - -- Check the statement list ends in an expression - case last stmts' of { - L _ (ResultStmt _) -> returnM () ; - other -> addLocErr other (doStmtListErr do_or_lc) - } `thenM_` - - -- Generate the rebindable syntax for the monad - lookupSyntaxNames syntax_names `thenM` \ (syntax_names', monad_fvs) -> - - returnM (HsDo do_or_lc stmts' syntax_names' placeHolderType, fvs `plusFV` monad_fvs) - where - syntax_names = case do_or_lc of - DoExpr -> monadNames - MDoExpr -> monadNames ++ [mfixName] - other -> [] +rnExpr e@(HsDo do_or_lc stmts body _) + = do { ((stmts', body'), fvs) <- rnStmts do_or_lc stmts $ + rnLExpr body + ; return (HsDo do_or_lc stmts' body' placeHolderType, fvs) } rnExpr (ExplicitList _ exps) = rnExprs exps `thenM` \ (exps', fvs) -> @@ -302,18 +210,20 @@ rnExpr e@(ExplicitTuple exps boxity) tup_size = length exps tycon_name = tupleTyCon_name boxity tup_size -rnExpr (RecordCon con_id rbinds) +rnExpr (RecordCon con_id _ rbinds) = lookupLocatedOccRn con_id `thenM` \ conname -> rnRbinds "construction" rbinds `thenM` \ (rbinds', fvRbinds) -> - returnM (RecordCon conname rbinds', fvRbinds `addOneFV` unLoc conname) + returnM (RecordCon conname noPostTcExpr rbinds', + fvRbinds `addOneFV` unLoc conname) -rnExpr (RecordUpd expr rbinds) - = rnLExpr expr `thenM` \ (expr', fvExpr) -> +rnExpr (RecordUpd expr rbinds _ _) + = rnLExpr expr `thenM` \ (expr', fvExpr) -> rnRbinds "update" rbinds `thenM` \ (rbinds', fvRbinds) -> - returnM (RecordUpd expr' rbinds', fvExpr `plusFV` fvRbinds) + returnM (RecordUpd expr' rbinds' placeHolderType placeHolderType, + fvExpr `plusFV` fvRbinds) rnExpr (ExprWithTySig expr pty) - = rnLExpr expr `thenM` \ (expr', fvExpr) -> + = rnLExpr expr `thenM` \ (expr', fvExpr) -> rnHsTypeFVs doc pty `thenM` \ (pty', fvTy) -> returnM (ExprWithTySig expr' pty', fvExpr `plusFV` fvTy) where @@ -331,13 +241,13 @@ rnExpr (HsType a) where doc = text "In a type argument" -rnExpr (ArithSeqIn seq) +rnExpr (ArithSeq _ seq) = rnArithSeq seq `thenM` \ (new_seq, fvs) -> - returnM (ArithSeqIn new_seq, fvs) + returnM (ArithSeq noPostTcExpr new_seq, fvs) -rnExpr (PArrSeqIn seq) +rnExpr (PArrSeq _ seq) = rnArithSeq seq `thenM` \ (new_seq, fvs) -> - returnM (PArrSeqIn new_seq, fvs) + returnM (PArrSeq noPostTcExpr new_seq, fvs) \end{code} These three are pattern syntax appearing in expressions. @@ -345,14 +255,9 @@ Since all the symbols are reservedops we can simply reject them. We return a (bogus) EWildPat in each case. \begin{code} -rnExpr e@EWildPat = addErr (patSynErr e) `thenM_` - returnM (EWildPat, emptyFVs) - -rnExpr e@(EAsPat _ _) = addErr (patSynErr e) `thenM_` - returnM (EWildPat, emptyFVs) - -rnExpr e@(ELazyPat _) = addErr (patSynErr e) `thenM_` - returnM (EWildPat, emptyFVs) +rnExpr e@EWildPat = patSynErr e +rnExpr e@(EAsPat {}) = patSynErr e +rnExpr e@(ELazyPat {}) = patSynErr e \end{code} %************************************************************************ @@ -363,19 +268,25 @@ rnExpr e@(ELazyPat _) = addErr (patSynErr e) `thenM_` \begin{code} rnExpr (HsProc pat body) - = rnPatsAndThen ProcExpr True [pat] $ \ [pat'] -> - rnCmdTop body `thenM` \ (body',fvBody) -> + = newArrowScope $ + rnPatsAndThen ProcExpr [pat] $ \ [pat'] -> + rnCmdTop body `thenM` \ (body',fvBody) -> returnM (HsProc pat' body', fvBody) rnExpr (HsArrApp arrow arg _ ho rtl) - = rnLExpr arrow `thenM` \ (arrow',fvArrow) -> - rnLExpr arg `thenM` \ (arg',fvArg) -> + = select_arrow_scope (rnLExpr arrow) `thenM` \ (arrow',fvArrow) -> + rnLExpr arg `thenM` \ (arg',fvArg) -> returnM (HsArrApp arrow' arg' placeHolderType ho rtl, fvArrow `plusFV` fvArg) + where + select_arrow_scope tc = case ho of + HsHigherOrderApp -> tc + HsFirstOrderApp -> escapeArrowScope tc -- infix form rnExpr (HsArrForm op (Just _) [arg1, arg2]) - = rnLExpr op `thenM` \ (op'@(L _ (HsVar op_name)),fv_op) -> + = escapeArrowScope (rnLExpr op) + `thenM` \ (op'@(L _ (HsVar op_name)),fv_op) -> rnCmdTop arg1 `thenM` \ (arg1',fv_arg1) -> rnCmdTop arg2 `thenM` \ (arg2',fv_arg2) -> @@ -388,39 +299,12 @@ rnExpr (HsArrForm op (Just _) [arg1, arg2]) fv_arg1 `plusFV` fv_op `plusFV` fv_arg2) rnExpr (HsArrForm op fixity cmds) - = rnLExpr op `thenM` \ (op',fvOp) -> - rnCmdArgs cmds `thenM` \ (cmds',fvCmds) -> + = escapeArrowScope (rnLExpr op) `thenM` \ (op',fvOp) -> + rnCmdArgs cmds `thenM` \ (cmds',fvCmds) -> returnM (HsArrForm op' fixity cmds', fvOp `plusFV` fvCmds) ---------------------------- --- Deal with fixity (cf mkOpAppRn for the method) - -mkOpFormRn :: LHsCmdTop Name -- Left operand; already rearranged - -> LHsExpr Name -> Fixity -- Operator and fixity - -> LHsCmdTop Name -- Right operand (not an infix) - -> RnM (HsCmd Name) - ---------------------------- --- (e11 `op1` e12) `op2` e2 -mkOpFormRn a1@(L loc (HsCmdTop (L _ (HsArrForm op1 (Just fix1) [a11,a12])) _ _ _)) - op2 fix2 a2 - | nofix_error - = addErr (precParseErr (ppr_op op1,fix1) (ppr_op op2,fix2)) `thenM_` - returnM (HsArrForm op2 (Just fix2) [a1, a2]) - - | associate_right - = mkOpFormRn a12 op2 fix2 a2 `thenM` \ new_c -> - returnM (HsArrForm op1 (Just fix1) - [a11, L loc (HsCmdTop (L loc new_c) [] placeHolderType [])]) - -- TODO: locs are wrong - where - (nofix_error, associate_right) = compareFixity fix1 fix2 - ---------------------------- --- Default case -mkOpFormRn arg1 op fix arg2 -- Default case, no rearrangment - = returnM (HsArrForm op (Just fix) [arg1, arg2]) - +rnExpr other = pprPanic "rnExpr: unexpected expression" (ppr other) + -- DictApp, DictLam, TyApp, TyLam \end{code} @@ -447,7 +331,7 @@ rnCmdTop = wrapLocFstM rnCmdTop' nameSetToList (methodNamesCmd (unLoc cmd')) in -- Generate the rebindable syntax for the monad - lookupSyntaxNames cmd_names `thenM` \ (cmd_names', cmd_fvs) -> + lookupSyntaxTable cmd_names `thenM` \ (cmd_names', cmd_fvs) -> returnM (HsCmdTop cmd' [] placeHolderType cmd_names', fvCmd `plusFV` cmd_fvs) @@ -481,22 +365,21 @@ convertOpFormsCmd (HsIf exp c1 c2) convertOpFormsCmd (HsLet binds cmd) = HsLet binds (convertOpFormsLCmd cmd) -convertOpFormsCmd (HsDo ctxt stmts ids ty) - = HsDo ctxt (map (fmap convertOpFormsStmt) stmts) ids ty +convertOpFormsCmd (HsDo ctxt stmts body ty) + = HsDo ctxt (map (fmap convertOpFormsStmt) stmts) + (convertOpFormsLCmd body) ty -- Anything else is unchanged. This includes HsArrForm (already done), -- things with no sub-commands, and illegal commands (which will be -- caught by the type checker) convertOpFormsCmd c = c -convertOpFormsStmt (BindStmt pat cmd) - = BindStmt pat (convertOpFormsLCmd cmd) -convertOpFormsStmt (ResultStmt cmd) - = ResultStmt (convertOpFormsLCmd cmd) -convertOpFormsStmt (ExprStmt cmd ty) - = ExprStmt (convertOpFormsLCmd cmd) ty -convertOpFormsStmt (RecStmt stmts lvs rvs es) - = RecStmt (map (fmap convertOpFormsStmt) stmts) lvs rvs es +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 = stmt convertOpFormsMatch (MatchGroup ms ty) @@ -508,11 +391,8 @@ convertOpFormsGRHSs (GRHSs grhss binds) = GRHSs (map convertOpFormsGRHS grhss) binds convertOpFormsGRHS = fmap convert - where convert (GRHS stmts) - = let - (L loc (ResultStmt cmd)) = last stmts - in - GRHS (init stmts ++ [L loc (ResultStmt (convertOpFormsLCmd cmd))]) + where + convert (GRHS stmts cmd) = GRHS stmts (convertOpFormsLCmd cmd) --------------------------------------------------- type CmdNeeds = FreeVars -- Only inhabitants are @@ -537,7 +417,8 @@ methodNamesCmd (HsIf p c1 c2) methodNamesCmd (HsLet b c) = methodNamesLCmd c -methodNamesCmd (HsDo sc stmts rbs ty) = methodNamesStmts stmts +methodNamesCmd (HsDo sc stmts body ty) + = methodNamesStmts stmts `plusFV` methodNamesLCmd body methodNamesCmd (HsApp c e) = methodNamesLCmd c @@ -562,7 +443,7 @@ methodNamesMatch (MatchGroup ms ty) methodNamesGRHSs (GRHSs grhss binds) = plusFVs (map methodNamesGRHS grhss) ------------------------------------------------- -methodNamesGRHS (L _ (GRHS stmts)) = methodNamesLStmt (last stmts) +methodNamesGRHS (L _ (GRHS stmts rhs)) = methodNamesLCmd rhs --------------------------------------------------- methodNamesStmts stmts = plusFVs (map methodNamesLStmt stmts) @@ -570,10 +451,9 @@ methodNamesStmts stmts = plusFVs (map methodNamesLStmt stmts) --------------------------------------------------- methodNamesLStmt = methodNamesStmt . unLoc -methodNamesStmt (ResultStmt cmd) = methodNamesLCmd cmd -methodNamesStmt (ExprStmt cmd ty) = methodNamesLCmd cmd -methodNamesStmt (BindStmt pat cmd ) = methodNamesLCmd cmd -methodNamesStmt (RecStmt stmts lvs rvs es) +methodNamesStmt (ExprStmt cmd _ _) = methodNamesLCmd cmd +methodNamesStmt (BindStmt pat cmd _ _) = methodNamesLCmd cmd +methodNamesStmt (RecStmt stmts _ _ _ _) = methodNamesStmts stmts `addOneFV` loopAName methodNamesStmt (LetStmt b) = emptyFVs methodNamesStmt (ParStmt ss) = emptyFVs @@ -641,33 +521,56 @@ rnRbinds str rbinds %************************************************************************ \begin{code} -rnBracket (VarBr n) = lookupOccRn n `thenM` \ name -> - returnM (VarBr name, unitFV name) -rnBracket (ExpBr e) = rnLExpr e `thenM` \ (e', fvs) -> - returnM (ExpBr e', fvs) -rnBracket (PatBr p) = rnLPat p `thenM` \ (p', fvs) -> - returnM (PatBr p', fvs) -rnBracket (TypBr t) = rnHsTypeFVs doc t `thenM` \ (t', fvs) -> - returnM (TypBr t', fvs) +rnBracket (VarBr n) = do { name <- lookupOccRn n + ; this_mod <- getModule + ; checkM (nameIsLocalOrFrom this_mod name) $ -- Reason: deprecation checking asumes the + do { loadHomeInterface msg name -- home interface is loaded, and this is the + ; return () } -- only way that is going to happen + ; returnM (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 p) = do { (p', fvs) <- rnLPat p + ; return (PatBr p', fvs) } +rnBracket (TypBr t) = do { (t', fvs) <- rnHsTypeFVs doc t + ; return (TypBr t', fvs) } where doc = ptext SLIT("In a Template-Haskell quoted type") rnBracket (DecBr group) - = importsFromLocalDecls group `thenM` \ (rdr_env, avails) -> - -- Discard avails (not useful here) - - updGblEnv (\gbl -> gbl { tcg_rdr_env = tcg_rdr_env gbl `plusOccEnv` rdr_env}) $ - -- Notice plusOccEnv, not plusGlobalRdrEnv. In this situation we want - -- to *shadow* top-level bindings. E.g. + = do { gbl_env <- getGblEnv + + ; let gbl_env1 = gbl_env { tcg_mod = thFAKE } + -- Note the 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. + + ; names <- getLocalDeclBinders gbl_env1 group + ; rdr_env' <- extendRdrEnvRn emptyGlobalRdrEnv names + -- Furthermore, the names in the bracket shouldn't conflict with + -- existing top-level names E.g. -- foo = 1 -- bar = [d| foo = 1|] - -- So we drop down to plusOccEnv. (Perhaps there should be a fn in RdrName.) - - rnSrcDecls group `thenM` \ (tcg_env, group') -> - -- Discard the tcg_env; it contains only extra info about fixity - let - dus = tcg_dus tcg_env - in - returnM (DecBr group', allUses dus) + -- But both 'foo's get a LocalDef provenance, so we'd get a complaint unless + -- we start with an emptyGlobalRdrEnv + + ; setGblEnv (gbl_env { tcg_rdr_env = tcg_rdr_env gbl_env1 `plusOccEnv` rdr_env', + tcg_dus = emptyDUs }) $ do + -- Notice plusOccEnv, not plusGlobalRdrEnv. In this situation we want + -- to *shadow* top-level bindings. (See the 'foo' example above.) + -- 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 emptyDUs is so that we just collect uses for this group alone + + { (tcg_env, group') <- rnSrcDecls group + -- Discard the tcg_env; it contains only extra info about fixity + ; return (DecBr group', allUses (tcg_dus tcg_env)) } } \end{code} %************************************************************************ @@ -677,105 +580,132 @@ rnBracket (DecBr group) %************************************************************************ \begin{code} -rnStmts :: HsStmtContext Name -> [LStmt RdrName] -> RnM ([LStmt Name], FreeVars) +rnStmts :: HsStmtContext Name -> [LStmt RdrName] + -> RnM (thing, FreeVars) + -> RnM (([LStmt Name], thing), FreeVars) -rnStmts MDoExpr = rnMDoStmts -rnStmts ctxt = rnNormalStmts ctxt +rnStmts (MDoExpr _) = rnMDoStmts +rnStmts ctxt = rnNormalStmts ctxt -rnNormalStmts :: HsStmtContext Name -> [LStmt RdrName] -> RnM ([LStmt Name], FreeVars) +rnNormalStmts :: HsStmtContext Name -> [LStmt RdrName] + -> RnM (thing, FreeVars) + -> RnM (([LStmt Name], thing), FreeVars) -- Used for cases *other* than recursive mdo -- Implements nested scopes -rnNormalStmts ctxt [] = returnM ([], emptyFVs) - -- Happens at the end of the sub-lists of a ParStmts - -rnNormalStmts ctxt (L loc (ExprStmt expr _) : stmts) - = rnLExpr expr `thenM` \ (expr', fv_expr) -> - rnNormalStmts ctxt stmts `thenM` \ (stmts', fvs) -> - returnM (L loc (ExprStmt expr' placeHolderType) : stmts', - fv_expr `plusFV` fvs) - -rnNormalStmts ctxt [L loc (ResultStmt expr)] - = rnLExpr expr `thenM` \ (expr', fv_expr) -> - returnM ([L loc (ResultStmt expr')], fv_expr) - -rnNormalStmts ctxt (L loc (BindStmt pat expr) : stmts) - = rnLExpr expr `thenM` \ (expr', fv_expr) -> - -- The binders do not scope over the expression +rnNormalStmts ctxt [] thing_inside + = do { (thing, fvs) <- thing_inside + ; return (([],thing), fvs) } - let - reportUnused = - case ctxt of - ParStmtCtxt{} -> False - _ -> True - in - rnPatsAndThen (StmtCtxt ctxt) reportUnused [pat] $ \ [pat'] -> - rnNormalStmts ctxt stmts `thenM` \ (stmts', fvs) -> - returnM (L loc (BindStmt pat' expr') : stmts', - fv_expr `plusFV` fvs) -- fv_expr shouldn't really be filtered by - -- the rnPatsAndThen, but it does not matter - -rnNormalStmts ctxt (L loc (LetStmt binds) : stmts) - = checkErr (ok ctxt binds) (badIpBinds binds) `thenM_` - rnBindGroupsAndThen binds ( \ binds' -> - rnNormalStmts ctxt stmts `thenM` \ (stmts', fvs) -> - returnM (L loc (LetStmt binds') : stmts', 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) } + +rnStmt :: HsStmtContext Name -> Stmt RdrName + -> RnM (thing, FreeVars) + -> RnM ((Stmt Name, thing), FreeVars) + +rnStmt ctxt (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), + fv_expr `plusFV` fvs1 `plusFV` fvs2) } + +rnStmt ctxt (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 (StmtCtxt ctxt) [pat] $ \ [pat'] -> do + { (thing, fvs3) <- thing_inside + ; return ((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 + = do { checkErr (ok ctxt binds) + (badIpBinds (ptext SLIT("a parallel list comprehension:")) binds) + ; rnLocalBindsAndThen binds $ \ binds' -> do + { (thing, fvs) <- thing_inside + ; return ((LetStmt binds', thing), fvs) }} where -- We do not allow implicit-parameter bindings in a parallel -- list comprehension. I'm not sure what it might mean. - ok (ParStmtCtxt _) binds = not (any is_ip_bind binds) - ok _ _ = True - - is_ip_bind (HsIPBinds _) = True - is_ip_bind _ = False - -rnNormalStmts ctxt (L loc (ParStmt stmtss) : stmts) - = doptM Opt_GlasgowExts `thenM` \ opt_GlasgowExts -> - checkM opt_GlasgowExts parStmtErr `thenM_` - mapFvRn rn_branch stmtss `thenM` \ (stmtss', fv_stmtss) -> - let - bndrss :: [[Name]] -- NB: Name, not RdrName - bndrss = map (map unLoc . collectStmtsBinders) stmtss' - (bndrs, dups) = removeDups cmpByOcc (concat bndrss) - in - mappM dupErr dups `thenM` \ _ -> - bindLocalNamesFV bndrs $ - -- Note: binders are returned in scope order, so one may - -- shadow the next; e.g. x <- xs; x <- ys - rnNormalStmts ctxt stmts `thenM` \ (stmts', fvs) -> + ok (ParStmtCtxt _) (HsIPBinds _) = False + ok _ _ = True - -- Cut down the exported binders to just the ones needed in the body - let - used_bndrs_s = map (filter (`elemNameSet` fvs)) bndrss - unused_bndrs = filter (not . (`elemNameSet` fvs)) bndrs - in - -- With processing of the branches and the tail of comprehension done, - -- we can finally compute&report any unused ParStmt binders. - warnUnusedMatches unused_bndrs `thenM_` - returnM (L loc (ParStmt (stmtss' `zip` used_bndrs_s)) : stmts', - fv_stmtss `plusFV` fvs) - where - rn_branch (stmts, _) = rnNormalStmts (ParStmtCtxt ctxt) stmts - - cmpByOcc n1 n2 = nameOccName n1 `compare` nameOccName n2 - dupErr (v:_) = addErr (ptext SLIT("Duplicate binding in parallel list comprehension for:") - <+> quotes (ppr v)) - -rnNormalStmts ctxt (L loc (RecStmt rec_stmts _ _ _) : stmts) - = bindLocatedLocalsRn doc (collectStmtsBinders rec_stmts) $ \ _ -> - rn_rec_stmts rec_stmts `thenM` \ segs -> - rnNormalStmts ctxt stmts `thenM` \ (stmts', fvs) -> +rnStmt ctxt (RecStmt rec_stmts _ _ _ _) thing_inside + = bindLocatedLocalsRn doc (collectLStmtsBinders rec_stmts) $ \ bndrs -> + rn_rec_stmts bndrs rec_stmts `thenM` \ segs -> + thing_inside `thenM` \ (thing, fvs) -> let 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 in - returnM (L loc (RecStmt rec_stmts' later_vars fwd_vars []) : stmts', - uses `plusFV` fvs) + returnM ((rec_stmt, thing), uses `plusFV` fvs) where doc = text "In a recursive do statement" + +rnStmt ctxt (ParStmt segs) thing_inside + = do { opt_GlasgowExts <- doptM Opt_GlasgowExts + ; checkM opt_GlasgowExts parStmtErr + ; orig_lcl_env <- getLocalRdrEnv + ; ((segs',thing), fvs) <- go orig_lcl_env [] segs + ; return ((ParStmt segs', thing), fvs) } + where +-- type ParSeg id = [([LStmt id], [id])] +-- go :: NameSet -> [ParSeg RdrName] +-- -> RnM (([ParSeg Name], thing), FreeVars) + + go orig_lcl_env bndrs [] + = do { let { (bndrs', dups) = removeDups cmpByOcc bndrs + ; inner_env = extendLocalRdrEnv orig_lcl_env bndrs' } + ; mappM dupErr dups + ; (thing, fvs) <- setLocalRdrEnv inner_env thing_inside + ; return (([], thing), fvs) } + + go orig_lcl_env bndrs_so_far ((stmts, _) : segs) + = do { ((stmts', (bndrs, segs', thing)), fvs) + <- rnNormalStmts par_ctxt stmts $ do + { -- Find the Names that are bound by stmts + lcl_env <- getLocalRdrEnv + ; let { rdr_bndrs = collectLStmtsBinders stmts + ; bndrs = map ( fromJust + . lookupLocalRdrEnv lcl_env + . unLoc) rdr_bndrs + ; new_bndrs = nub bndrs ++ bndrs_so_far + -- The nub is because there might be shadowing + -- x <- e1; x <- e2 + -- So we'll look up (Unqual x) twice, getting + -- the second binding both times, which is the + } -- one we want + + -- Typecheck the thing inside, passing on all + -- the Names bound, but separately; revert the envt + ; ((segs', thing), fvs) <- setLocalRdrEnv orig_lcl_env $ + go orig_lcl_env new_bndrs segs + + -- Figure out which of the bound names are used + ; let used_bndrs = filter (`elemNameSet` fvs) bndrs + ; return ((used_bndrs, segs', thing), fvs) } + + ; let seg' = (stmts', bndrs) + ; return (((seg':segs'), thing), + delListFromNameSet fvs bndrs) } + + par_ctxt = ParStmtCtxt ctxt + + cmpByOcc n1 n2 = nameOccName n1 `compare` nameOccName n2 + dupErr vs = addErr (ptext SLIT("Duplicate binding in parallel list comprehension for:") + <+> quotes (ppr (head vs))) \end{code} @@ -796,88 +726,93 @@ type Segment stmts = (Defs, ---------------------------------------------------- -rnMDoStmts :: [LStmt RdrName] -> RnM ([LStmt Name], FreeVars) -rnMDoStmts stmts +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 - bindLocatedLocalsRn doc (collectStmtsBinders stmts) $ \ _ -> - + bindLocatedLocalsRn doc (collectLStmtsBinders stmts) $ \ bndrs -> + do { -- Step 2: 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 stmts `thenM` \ segs -> - let + segs <- rn_rec_stmts bndrs stmts + + ; (thing, fvs_later) <- thing_inside + + ; let -- Step 3: 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 + segs_w_fwd_refs = addFwdRefs segs -- Step 4: 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 + grouped_segs = glomSegments segs_w_fwd_refs -- Step 5: 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_w_fvs = segsToStmts grouped_segs - in - returnM stmts_w_fvs + (stmts', fvs) = segsToStmts grouped_segs fvs_later + + ; return ((stmts', thing), fvs) } where - doc = text "In a mdo-expression" + doc = text "In a recursive mdo-expression" +--------------------------------------------- +rn_rec_stmts :: [Name] -> [LStmt RdrName] -> RnM [Segment (LStmt Name)] +rn_rec_stmts bndrs stmts = mappM (rn_rec_stmt bndrs) stmts `thenM` \ segs_s -> + returnM (concat segs_s) ---------------------------------------------------- -rn_rec_stmt :: LStmt RdrName -> RnM [Segment (LStmt Name)] +rn_rec_stmt :: [Name] -> LStmt RdrName -> RnM [Segment (LStmt Name)] -- Rename a Stmt that is inside a RecStmt (or mdo) -- Assumes all binders are already in scope -- Turns each stmt into a singleton Stmt -rn_rec_stmt (L loc (ExprStmt expr _)) +rn_rec_stmt all_bndrs (L loc (ExprStmt expr _ _)) = rnLExpr expr `thenM` \ (expr', fvs) -> - returnM [(emptyNameSet, fvs, emptyNameSet, - L loc (ExprStmt expr' placeHolderType))] + lookupSyntaxName thenMName `thenM` \ (then_op, fvs1) -> + returnM [(emptyNameSet, fvs `plusFV` fvs1, emptyNameSet, + L loc (ExprStmt expr' then_op placeHolderType))] -rn_rec_stmt (L loc (ResultStmt expr)) - = rnLExpr expr `thenM` \ (expr', fvs) -> - returnM [(emptyNameSet, fvs, emptyNameSet, - L loc (ResultStmt expr'))] - -rn_rec_stmt (L loc (BindStmt pat expr)) +rn_rec_stmt all_bndrs (L loc (BindStmt pat expr _ _)) = rnLExpr expr `thenM` \ (expr', fv_expr) -> - rnLPat pat `thenM` \ (pat', fv_pat) -> + rnLPat pat `thenM` \ (pat', fv_pat) -> + lookupSyntaxName bindMName `thenM` \ (bind_op, fvs1) -> + lookupSyntaxName failMName `thenM` \ (fail_op, fvs2) -> let bndrs = mkNameSet (collectPatBinders pat') - fvs = fv_expr `plusFV` fv_pat + fvs = fv_expr `plusFV` fv_pat `plusFV` fvs1 `plusFV` fvs2 in returnM [(bndrs, fvs, bndrs `intersectNameSet` fvs, - L loc (BindStmt pat' expr'))] + L loc (BindStmt pat' expr' bind_op fail_op))] + +rn_rec_stmt all_bndrs (L loc (LetStmt binds@(HsIPBinds _))) + = do { addErr (badIpBinds (ptext SLIT("an mdo expression")) binds) + ; failM } -rn_rec_stmt (L loc (LetStmt binds)) - = rnBindGroups binds `thenM` \ (binds', du_binds) -> +rn_rec_stmt all_bndrs (L loc (LetStmt (HsValBinds binds))) + = rnValBinds (trimWith all_bndrs) binds `thenM` \ (binds', du_binds) -> returnM [(duDefs du_binds, duUses du_binds, - emptyNameSet, L loc (LetStmt binds'))] + emptyNameSet, L loc (LetStmt (HsValBinds binds')))] -rn_rec_stmt (L loc (RecStmt stmts _ _ _)) -- Flatten Rec inside Rec - = rn_rec_stmts stmts +rn_rec_stmt all_bndrs (L loc (RecStmt stmts _ _ _ _)) -- Flatten Rec inside Rec + = rn_rec_stmts all_bndrs stmts -rn_rec_stmt stmt@(L _ (ParStmt _)) -- Syntactically illegal in mdo +rn_rec_stmt all_bndrs stmt@(L _ (ParStmt _)) -- Syntactically illegal in mdo = pprPanic "rn_rec_stmt" (ppr stmt) --------------------------------------------- -rn_rec_stmts :: [LStmt RdrName] -> RnM [Segment (LStmt Name)] -rn_rec_stmts stmts = mappM rn_rec_stmt stmts `thenM` \ segs_s -> - returnM (concat segs_s) - - ---------------------------------------------- addFwdRefs :: [Segment a] -> [Segment a] -- So far the segments only have forward refs *within* the Stmt -- (which happens for bind: x <- ...x...) @@ -958,17 +893,20 @@ glomSegments ((defs,uses,fwds,stmt) : segs) ---------------------------------------------------- -segsToStmts :: [Segment [LStmt Name]] -> ([LStmt Name], FreeVars) +segsToStmts :: [Segment [LStmt Name]] + -> FreeVars -- Free vars used 'later' + -> ([LStmt Name], FreeVars) -segsToStmts [] = ([], emptyFVs) -segsToStmts ((defs, uses, fwds, ss) : segs) +segsToStmts [] fvs_later = ([], fvs_later) +segsToStmts ((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 + (later_stmts, later_uses) = segsToStmts segs fvs_later new_stmt | non_rec = head ss | otherwise = L (getLoc (head ss)) $ - RecStmt ss (nameSetToList used_later) (nameSetToList fwds) [] + RecStmt ss (nameSetToList used_later) (nameSetToList fwds) + [] emptyLHsBinds where non_rec = isSingleton ss && isEmptyNameSet fwds used_later = defs `intersectNameSet` later_uses @@ -977,151 +915,6 @@ segsToStmts ((defs, uses, fwds, ss) : segs) %************************************************************************ %* * -\subsubsection{Precedence Parsing} -%* * -%************************************************************************ - -@mkOpAppRn@ deals with operator fixities. The argument expressions -are assumed to be already correctly arranged. It needs the fixities -recorded in the OpApp nodes, because fixity info applies to the things -the programmer actually wrote, so you can't find it out from the Name. - -Furthermore, the second argument is guaranteed not to be another -operator application. Why? Because the parser parses all -operator appications left-associatively, EXCEPT negation, which -we need to handle specially. - -\begin{code} -mkOpAppRn :: LHsExpr Name -- Left operand; already rearranged - -> LHsExpr Name -> Fixity -- Operator and fixity - -> LHsExpr Name -- Right operand (not an OpApp, but might - -- be a NegApp) - -> RnM (HsExpr Name) - ---------------------------- --- (e11 `op1` e12) `op2` e2 -mkOpAppRn e1@(L _ (OpApp e11 op1 fix1 e12)) op2 fix2 e2 - | nofix_error - = addErr (precParseErr (ppr_op op1,fix1) (ppr_op op2,fix2)) `thenM_` - returnM (OpApp e1 op2 fix2 e2) - - | associate_right - = mkOpAppRn e12 op2 fix2 e2 `thenM` \ new_e -> - returnM (OpApp e11 op1 fix1 (L loc' new_e)) - where - loc'= combineLocs e12 e2 - (nofix_error, associate_right) = compareFixity fix1 fix2 - ---------------------------- --- (- neg_arg) `op` e2 -mkOpAppRn e1@(L _ (NegApp neg_arg neg_name)) op2 fix2 e2 - | nofix_error - = addErr (precParseErr (pp_prefix_minus,negateFixity) (ppr_op op2,fix2)) `thenM_` - returnM (OpApp e1 op2 fix2 e2) - - | associate_right - = mkOpAppRn neg_arg op2 fix2 e2 `thenM` \ new_e -> - returnM (NegApp (L loc' new_e) neg_name) - where - loc' = combineLocs neg_arg e2 - (nofix_error, associate_right) = compareFixity negateFixity fix2 - ---------------------------- --- e1 `op` - neg_arg -mkOpAppRn e1 op1 fix1 e2@(L _ (NegApp neg_arg _)) -- NegApp can occur on the right - | not associate_right -- We *want* right association - = addErr (precParseErr (ppr_op op1, fix1) (pp_prefix_minus, negateFixity)) `thenM_` - returnM (OpApp e1 op1 fix1 e2) - where - (_, associate_right) = compareFixity fix1 negateFixity - ---------------------------- --- Default case -mkOpAppRn e1 op fix e2 -- Default case, no rearrangment - = ASSERT2( right_op_ok fix (unLoc e2), - ppr e1 $$ text "---" $$ ppr op $$ text "---" $$ ppr fix $$ text "---" $$ ppr e2 - ) - returnM (OpApp e1 op fix e2) - --- Parser left-associates everything, but --- derived instances may have correctly-associated things to --- in the right operarand. So we just check that the right operand is OK -right_op_ok fix1 (OpApp _ _ fix2 _) - = not error_please && associate_right - where - (error_please, associate_right) = compareFixity fix1 fix2 -right_op_ok fix1 other - = True - --- Parser initially makes negation bind more tightly than any other operator --- And "deriving" code should respect this (use HsPar if not) -mkNegAppRn :: LHsExpr id -> SyntaxName -> RnM (HsExpr id) -mkNegAppRn neg_arg neg_name - = ASSERT( not_op_app (unLoc neg_arg) ) - returnM (NegApp neg_arg neg_name) - -not_op_app (OpApp _ _ _ _) = False -not_op_app other = True -\end{code} - -\begin{code} -checkPrecMatch :: Bool -> Name -> MatchGroup Name -> RnM () - -- True indicates an infix lhs - -- See comments with rnExpr (OpApp ...) about "deriving" - -checkPrecMatch False fn match - = returnM () -checkPrecMatch True op (MatchGroup ms _) - = mapM_ check ms - where - check (L _ (Match (p1:p2:_) _ _)) - = checkPrec op (unLoc p1) False `thenM_` - checkPrec op (unLoc p2) True - - check _ = panic "checkPrecMatch" - -checkPrec op (ConPatIn op1 (InfixCon _ _)) right - = lookupFixityRn op `thenM` \ op_fix@(Fixity op_prec op_dir) -> - lookupFixityRn (unLoc op1) `thenM` \ op1_fix@(Fixity op1_prec op1_dir) -> - let - inf_ok = op1_prec > op_prec || - (op1_prec == op_prec && - (op1_dir == InfixR && op_dir == InfixR && right || - op1_dir == InfixL && op_dir == InfixL && not right)) - - info = (ppr_op op, op_fix) - info1 = (ppr_op op1, op1_fix) - (infol, infor) = if right then (info, info1) else (info1, info) - in - checkErr inf_ok (precParseErr infol infor) - -checkPrec op pat right - = returnM () - --- Check precedence of (arg op) or (op arg) respectively --- If arg is itself an operator application, then either --- (a) its precedence must be higher than that of op --- (b) its precedency & associativity must be the same as that of op -checkSectionPrec :: FixityDirection -> HsExpr RdrName - -> LHsExpr Name -> LHsExpr Name -> RnM () -checkSectionPrec direction section op arg - = case unLoc arg of - OpApp _ op fix _ -> go_for_it (ppr_op op) fix - NegApp _ _ -> go_for_it pp_prefix_minus negateFixity - other -> returnM () - where - L _ (HsVar op_name) = op - go_for_it pp_arg_op arg_fix@(Fixity arg_prec assoc) - = lookupFixityRn op_name `thenM` \ op_fix@(Fixity op_prec _) -> - checkErr (op_prec < arg_prec - || op_prec == arg_prec && direction == assoc) - (sectionPrecErr (ppr_op op_name, op_fix) - (pp_arg_op, arg_fix) section) -\end{code} - - -%************************************************************************ -%* * \subsubsection{Assertion utils} %* * %************************************************************************ @@ -1133,7 +926,7 @@ mkAssertErrorExpr = getSrcSpanM `thenM` \ sloc -> let expr = HsApp (L sloc (HsVar assertErrorName)) (L sloc (HsLit msg)) - msg = HsStringPrim (mkFastString (stringToUtf8 (showSDoc (ppr sloc)))) + msg = HsStringPrim (mkFastString (showSDoc (ppr sloc))) in returnM (expr, emptyFVs) \end{code} @@ -1145,38 +938,13 @@ mkAssertErrorExpr %************************************************************************ \begin{code} -ppr_op op = quotes (ppr op) -- Here, op can be a Name or a (Var n), where n is a Name -pp_prefix_minus = ptext SLIT("prefix `-'") - -nonStdGuardErr guard - = hang (ptext - SLIT("accepting non-standard pattern guards (-fglasgow-exts to suppress this message)") - ) 4 (ppr guard) - -patSynErr e - = sep [ptext SLIT("Pattern syntax in expression context:"), - nest 4 (ppr e)] - -doStmtListErr do_or_lc e - = sep [quotes (text binder_name) <+> ptext SLIT("statements must end in expression:"), - nest 4 (ppr e)] - where - binder_name = case do_or_lc of - MDoExpr -> "mdo" - other -> "do" - -#ifdef GHCI -checkTH e what = returnM () -- OK -#else -checkTH e what -- Raise an error in a stage-1 compiler - = addErr (vcat [ptext SLIT("Template Haskell") <+> text what <+> - ptext SLIT("illegal in a stage-1 compiler"), - nest 2 (ppr e)]) -#endif +patSynErr e = do { addErr (sep [ptext SLIT("Pattern syntax in expression context:"), + nest 4 (ppr e)]) + ; return (EWildPat, emptyFVs) } parStmtErr = addErr (ptext SLIT("Illegal parallel list comprehension: use -fglasgow-exts")) -badIpBinds binds - = hang (ptext SLIT("Implicit-parameter bindings illegal in a parallel list comprehension:")) 4 - (ppr binds) +badIpBinds what binds + = hang (ptext SLIT("Implicit-parameter bindings illegal in") <+> what) + 2 (ppr binds) \end{code}