Allow multiple context managers in one with statement, as proposed

in http://codereview.appspot.com/53094 and accepted by Guido.

The construct is transformed into multiple With AST nodes so that
there should be no problems with the semantics.

diff --git a/Doc/reference/compound_stmts.rst b/Doc/reference/compound_stmts.rst
index afb7ebc6d50151e3f6fc9a8552e836177c41820f..354ed1f268aefb58d71766cc34360d1f527beec4 100644 (file)
--- a/Doc/reference/compound_stmts.rst
+++ b/Doc/reference/compound_stmts.rst
@@ -333,9 +333,10 @@ allows common :keyword:`try`...\ :keyword:`except`...\ :keyword:`finally` usage
 patterns to be encapsulated for convenient reuse.
 
 .. productionlist::
-   with_stmt: "with" `expression` ["as" `target`] ":" `suite`
+   with_stmt: "with" with_item ("," with_item)* ":" `suite`
+   with_item: `expression` ["as" `target`]
 
-The execution of the :keyword:`with` statement proceeds as follows:
+The execution of the :keyword:`with` statement with one "item" proceeds as follows:
 
 #. The context expression is evaluated to obtain a context manager.
 
@@ -369,12 +370,27 @@ The execution of the :keyword:`with` statement proceeds as follows:
    from :meth:`__exit__` is ignored, and execution proceeds at the normal location
    for the kind of exit that was taken.
 
+With more than one item, the context managers are processed as if multiple
+:keyword:`with` statements were nested::
+
+   with A() as a, B() as b:
+       suite
+
+is equivalent to ::
+
+   with A() as a:
+       with B() as b:
+           suite
+
 .. note::
 
    In Python 2.5, the :keyword:`with` statement is only allowed when the
    ``with_statement`` feature has been enabled.  It is always enabled in
    Python 2.6.
 
+.. versionchanged:: 2.7
+   Support for multiple context expressions.
+
 .. seealso::
 
    :pep:`0343` - The "with" statement

diff --git a/Grammar/Grammar b/Grammar/Grammar
index 865d44c19d1ffd8bfa901138e4998dee3fe0c24c..266ba41b8172b5d7502f2385e603054ab8816c04 100644 (file)
--- a/Grammar/Grammar
+++ b/Grammar/Grammar
@@ -83,8 +83,8 @@ try_stmt: ('try' ':' suite
            ['else' ':' suite]
            ['finally' ':' suite] |
           'finally' ':' suite))
-with_stmt: 'with' test [ with_var ] ':' suite
-with_var: 'as' expr
+with_stmt: 'with' with_item (',' with_item)*  ':' suite
+with_item: test ['as' expr]
 # NB compile.c makes sure that the default except clause is last
 except_clause: 'except' [test [('as' | ',') test]]
 suite: simple_stmt | NEWLINE INDENT stmt+ DEDENT

diff --git a/Include/graminit.h b/Include/graminit.h
index 38b4dacff16125aa5eda10a291f16718d4c80420..6df6509bbfb26823d8e9fb22a9da5a1465220825 100644 (file)
--- a/Include/graminit.h
+++ b/Include/graminit.h
@@ -42,7 +42,7 @@
 #define for_stmt 295
 #define try_stmt 296
 #define with_stmt 297
-#define with_var 298
+#define with_item 298
 #define except_clause 299
 #define suite 300
 #define testlist_safe 301

diff --git a/Lib/compiler/transformer.py b/Lib/compiler/transformer.py
index f5fe582bc95c9c052cd42dc987e020b0d3774b9e..2a156d344cf29465a66ffda55ec71f16d7c6eae7 100644 (file)
--- a/Lib/compiler/transformer.py
+++ b/Lib/compiler/transformer.py
@@ -965,18 +965,22 @@ class Transformer:
             return try_except
 
     def com_with(self, nodelist):
-        # with_stmt: 'with' expr [with_var] ':' suite
-        expr = self.com_node(nodelist[1])
+        # with_stmt: 'with' with_item (',' with_item)* ':' suite
         body = self.com_node(nodelist[-1])
-        if nodelist[2][0] == token.COLON:
-            var = None
+        for i in range(len(nodelist) - 3, 0, -2):
+            ret = self.com_with_item(nodelist[i], body, nodelist[0][2])
+            if i == 1:
+                return ret
+            body = ret
+
+    def com_with_item(self, nodelist, body, lineno):
+        # with_item: test ['as' expr]
+        if len(nodelist) == 4:
+            var = self.com_assign(nodelist[3], OP_ASSIGN)
         else:
-            var = self.com_assign(nodelist[2][2], OP_ASSIGN)
-        return With(expr, var, body, lineno=nodelist[0][2])
-
-    def com_with_var(self, nodelist):
-        # with_var: 'as' expr
-        return self.com_node(nodelist[1])
+            var = None
+        expr = self.com_node(nodelist[1])
+        return With(expr, var, body, lineno=lineno)
 
     def com_augassign_op(self, node):
         assert node[0] == symbol.augassign

diff --git a/Lib/test/test_compiler.py b/Lib/test/test_compiler.py
index 052e07e8ffd657ebc5a25f222337248280b1a1c4..f1fef748779233fea6841dd22683df4f923f8c0c 100644 (file)
--- a/Lib/test/test_compiler.py
+++ b/Lib/test/test_compiler.py
@@ -165,6 +165,27 @@ class CompilerTest(unittest.TestCase):
         exec c in dct
         self.assertEquals(dct.get('result'), 1)
 
+    def testWithMult(self):
+        events = []
+        class Ctx:
+            def __init__(self, n):
+                self.n = n
+            def __enter__(self):
+                events.append(self.n)
+            def __exit__(self, *args):
+                pass
+        c = compiler.compile('from __future__ import with_statement\n'
+                             'def f():\n'
+                             '    with Ctx(1) as tc, Ctx(2) as tc2:\n'
+                             '        return 1\n'
+                             'result = f()',
+                             '<string>',
+                             'exec' )
+        dct = {'Ctx': Ctx}
+        exec c in dct
+        self.assertEquals(dct.get('result'), 1)
+        self.assertEquals(events, [1, 2])
+
     def testGlobal(self):
         code = compiler.compile('global x\nx=1', '<string>', 'exec')
         d1 = {'__builtins__': {}}

diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py
index 23f418ee39589cb8a8b0ccbe3d1483725e560ada..7d059c20f20cdbdafd1f8734ef7eb3448fac7908 100644 (file)
--- a/Lib/test/test_parser.py
+++ b/Lib/test/test_parser.py
@@ -199,6 +199,7 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase):
     def test_with(self):
         self.check_suite("with open('x'): pass\n")
         self.check_suite("with open('x') as f: pass\n")
+        self.check_suite("with open('x') as f, open('y') as g: pass\n")
 
     def test_try_stmt(self):
         self.check_suite("try: pass\nexcept: pass\n")

diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index bfeb06bdd9baa539c07e0ed4be6e1f18831bdb4b..68ae890f3d2486781f468ee8256a7353a9c4d916 100644 (file)
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -654,12 +654,88 @@ class ExitSwallowsExceptionTestCase(unittest.TestCase):
             self.fail("ZeroDivisionError should have been raised")
 
 
+class NestedWith(unittest.TestCase):
+
+    class Dummy(object):
+        def __init__(self, value=None, gobble=False):
+            if value is None:
+                value = self
+            self.value = value
+            self.gobble = gobble
+            self.enter_called = False
+            self.exit_called = False
+
+        def __enter__(self):
+            self.enter_called = True
+            return self.value
+
+        def __exit__(self, *exc_info):
+            self.exit_called = True
+            self.exc_info = exc_info
+            if self.gobble:
+                return True
+
+    class CtorRaises(object):
+        def __init__(self): raise RuntimeError()
+
+    class EnterRaises(object):
+        def __enter__(self): raise RuntimeError()
+        def __exit__(self, *exc_info): pass
+
+    class ExitRaises(object):
+        def __enter__(self): pass
+        def __exit__(self, *exc_info): raise RuntimeError()
+
+    def testNoExceptions(self):
+        with self.Dummy() as a, self.Dummy() as b:
+            self.assertTrue(a.enter_called)
+            self.assertTrue(b.enter_called)
+        self.assertTrue(a.exit_called)
+        self.assertTrue(b.exit_called)
+
+    def testExceptionInExprList(self):
+        try:
+            with self.Dummy() as a, self.CtorRaises():
+                pass
+        except:
+            pass
+        self.assertTrue(a.enter_called)
+        self.assertTrue(a.exit_called)
+
+    def testExceptionInEnter(self):
+        try:
+            with self.Dummy() as a, self.EnterRaises():
+                self.fail('body of bad with executed')
+        except RuntimeError:
+            pass
+        else:
+            self.fail('RuntimeError not reraised')
+        self.assertTrue(a.enter_called)
+        self.assertTrue(a.exit_called)
+
+    def testExceptionInExit(self):
+        body_executed = False
+        with self.Dummy(gobble=True) as a, self.ExitRaises():
+            body_executed = True
+        self.assertTrue(a.enter_called)
+        self.assertTrue(a.exit_called)
+        self.assertNotEqual(a.exc_info[0], None)
+
+    def testEnterReturnsTuple(self):
+        with self.Dummy(value=(1,2)) as (a1, a2), \
+             self.Dummy(value=(10, 20)) as (b1, b2):
+            self.assertEquals(1, a1)
+            self.assertEquals(2, a2)
+            self.assertEquals(10, b1)
+            self.assertEquals(20, b2)
+
 def test_main():
     run_unittest(FailureTestCase, NonexceptionalTestCase,
                  NestedNonexceptionalTestCase, ExceptionalTestCase,
                  NonLocalFlowControlTestCase,
                  AssignmentTargetTestCase,
-                 ExitSwallowsExceptionTestCase)
+                 ExitSwallowsExceptionTestCase,
+                 NestedWith)
 
 
 if __name__ == '__main__':

diff --git a/Misc/NEWS b/Misc/NEWS
index a6b5fce442005790ded8b7ed2b6823b2c1f6f110..daab366c3d18bfee36d3c977bfac39c897ba785b 100644 (file)
--- a/Misc/NEWS
+++ b/Misc/NEWS
@@ -12,6 +12,8 @@ What's New in Python 2.7 alpha 1
 Core and Builtins
 -----------------
 
+- Added support for multiple context managers in the same with statement.
+
 - Issue #6101: A new opcode, SETUP_WITH, has been added to speed up the with
   statement and correctly lookup the __enter__ and __exit__ special methods.
 

diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index a4a641662f3b6363464ba98fdde31aa875c4621b..42989b7b8e12bd4a29a91d41b290d8415e39cc32 100644 (file)
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -2618,36 +2618,39 @@ validate_decorators(node *tree)
     return ok;
 }
 
-/*  with_var
-with_var: 'as' expr
+/*  with_item:
+ *   test ['as' expr]
  */
 static int
-validate_with_var(node *tree)
+validate_with_item(node *tree)
 {
     int nch = NCH(tree);
-    int ok = (validate_ntype(tree, with_var)
-        && (nch == 2)
-        && validate_name(CHILD(tree, 0), "as")
-        && validate_expr(CHILD(tree, 1)));
-   return ok;
+    int ok = (validate_ntype(tree, with_item)
+              && (nch == 1 || nch == 3)
+              && validate_test(CHILD(tree, 0)));
+    if (ok && nch == 3) 
+        ok = (validate_name(CHILD(tree, 1), "as")
+              && validate_expr(CHILD(tree, 2)));
+    return ok;
 }
 
-/*  with_stmt
- *           0      1       2       -2   -1
-with_stmt: 'with' test [ with_var ] ':' suite
+/*  with_stmt:
+ *    0      1          ...             -2   -1
+ *   'with' with_item (',' with_item)* ':' suite
  */
 static int
 validate_with_stmt(node *tree)
 {
+    int i;
     int nch = NCH(tree);
     int ok = (validate_ntype(tree, with_stmt)
-        && ((nch == 4) || (nch == 5))
+        && (nch % 2 == 0)
         && validate_name(CHILD(tree, 0), "with")
-        && validate_test(CHILD(tree, 1))
-        && (nch == 4 || validate_with_var(CHILD(tree, 2))) 
         && validate_colon(RCHILD(tree, -2))
         && validate_suite(RCHILD(tree, -1)));
-   return ok;
+    for (i = 1; ok && i < nch - 2; i += 2)
+        ok = validate_with_item(CHILD(tree, i));
+    return ok;
 }
 
 /*  funcdef:

diff --git a/Python/ast.c b/Python/ast.c
index 5f369b6626807c4ec6a01ac69f8fa87f9e3d7f50..271585f2e237d0fcf3e9324bc9006c7e2a70ad90 100644 (file)
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -3009,27 +3009,18 @@ ast_for_try_stmt(struct compiling *c, const node *n)
     return TryFinally(body, finally, LINENO(n), n->n_col_offset, c->c_arena);
 }
 
-static expr_ty
-ast_for_with_var(struct compiling *c, const node *n)
-{
-    REQ(n, with_var);
-    return ast_for_expr(c, CHILD(n, 1));
-}
-
-/* with_stmt: 'with' test [ with_var ] ':' suite */
+/* with_item: test ['as' expr] */
 static stmt_ty
-ast_for_with_stmt(struct compiling *c, const node *n)
+ast_for_with_item(struct compiling *c, const node *n, asdl_seq *content)
 {
     expr_ty context_expr, optional_vars = NULL;
-    int suite_index = 3;    /* skip 'with', test, and ':' */
-    asdl_seq *suite_seq;
 
-    assert(TYPE(n) == with_stmt);
-    context_expr = ast_for_expr(c, CHILD(n, 1));
+    REQ(n, with_item);
+    context_expr = ast_for_expr(c, CHILD(n, 0));
     if (!context_expr)
         return NULL;
-    if (TYPE(CHILD(n, 2)) == with_var) {
-        optional_vars = ast_for_with_var(c, CHILD(n, 2));
+    if (NCH(n) == 3) {
+        optional_vars = ast_for_expr(c, CHILD(n, 2));
 
         if (!optional_vars) {
             return NULL;
@@ -3037,15 +3028,45 @@ ast_for_with_stmt(struct compiling *c, const node *n)
         if (!set_context(c, optional_vars, Store, n)) {
             return NULL;
         }
-        suite_index = 4;
     }
 
-    suite_seq = ast_for_suite(c, CHILD(n, suite_index));
-    if (!suite_seq) {
+    return With(context_expr, optional_vars, content, LINENO(n),
+                n->n_col_offset, c->c_arena);
+}
+
+/* with_stmt: 'with' with_item (',' with_item)* ':' suite */
+static stmt_ty
+ast_for_with_stmt(struct compiling *c, const node *n)
+{
+    int i;
+    stmt_ty ret;
+    asdl_seq *inner;
+
+    REQ(n, with_stmt);
+
+    /* process the with items inside-out */
+    i = NCH(n) - 1;
+    /* the suite of the innermost with item is the suite of the with stmt */
+    inner = ast_for_suite(c, CHILD(n, i));
+    if (!inner)
         return NULL;
+
+    for (;;) {
+        i -= 2;
+        ret = ast_for_with_item(c, CHILD(n, i), inner);
+        if (!ret)
+            return NULL;
+        /* was this the last item? */
+        if (i == 1)
+            break;
+        /* if not, wrap the result so far in a new sequence */
+        inner = asdl_seq_new(1, c->c_arena);
+        if (!inner)
+            return NULL;
+        asdl_seq_SET(inner, 0, ret);
     }
-    return With(context_expr, optional_vars, suite_seq, LINENO(n), 
-                n->n_col_offset, c->c_arena);
+
+    return ret;
 }
 
 static stmt_ty

diff --git a/Python/graminit.c b/Python/graminit.c
index ec2f4215f4caa091bbe18493e3caf291d03af439..2e3e9e86a48582acfeddecdd1d8dd01bc13bd0d2 100644 (file)
--- a/Python/graminit.c
+++ b/Python/graminit.c
@@ -901,42 +901,43 @@ static arc arcs_41_0[1] = {
        {100, 1},
 };
 static arc arcs_41_1[1] = {
-       {28, 2},
+       {101, 2},
 };
 static arc arcs_41_2[2] = {
-       {101, 3},
-       {23, 4},
+       {29, 1},
+       {23, 3},
 };
 static arc arcs_41_3[1] = {
-       {23, 4},
+       {24, 4},
 };
 static arc arcs_41_4[1] = {
-       {24, 5},
-};
-static arc arcs_41_5[1] = {
-       {0, 5},
+       {0, 4},
 };
-static state states_41[6] = {
+static state states_41[5] = {
        {1, arcs_41_0},
        {1, arcs_41_1},
        {2, arcs_41_2},
        {1, arcs_41_3},
        {1, arcs_41_4},
-       {1, arcs_41_5},
 };
 static arc arcs_42_0[1] = {
-       {80, 1},
+       {28, 1},
 };
-static arc arcs_42_1[1] = {
-       {84, 2},
+static arc arcs_42_1[2] = {
+       {80, 2},
+       {0, 1},
 };
 static arc arcs_42_2[1] = {
-       {0, 2},
+       {84, 3},
+};
+static arc arcs_42_3[1] = {
+       {0, 3},
 };
-static state states_42[3] = {
+static state states_42[4] = {
        {1, arcs_42_0},
-       {1, arcs_42_1},
+       {2, arcs_42_1},
        {1, arcs_42_2},
+       {1, arcs_42_3},
 };
 static arc arcs_43_0[1] = {
        {102, 1},
@@ -1877,10 +1878,10 @@ static dfa dfas[85] = {
         "\000\000\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000"},
        {296, "try_stmt", 0, 13, states_40,
         "\000\000\000\000\000\000\000\000\000\000\000\000\002\000\000\000\000\000\000\000\000\000"},
-       {297, "with_stmt", 0, 6, states_41,
+       {297, "with_stmt", 0, 5, states_41,
         "\000\000\000\000\000\000\000\000\000\000\000\000\020\000\000\000\000\000\000\000\000\000"},
-       {298, "with_var", 0, 3, states_42,
-        "\000\000\000\000\000\000\000\000\000\000\001\000\000\000\000\000\000\000\000\000\000\000"},
+       {298, "with_item", 0, 4, states_42,
+        "\000\040\040\000\000\000\000\000\000\000\000\000\000\040\010\000\200\041\044\015\000\000"},
        {299, "except_clause", 0, 5, states_43,
         "\000\000\000\000\000\000\000\000\000\000\000\000\100\000\000\000\000\000\000\000\000\000"},
        {300, "suite", 0, 5, states_44,