Another "if 0:" hack, this time to complain about otherwise invisible

"return expr" instances in generators (which latter may be generators
due to otherwise invisible "yield" stmts hiding in "if 0" blocks).
This was fun the first time, but this has gotten truly ugly now.

diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py
index 3dd468b1cc2788b1eb64232c835ac36affc967f7..7b78b2bed0e4059cea3285cd1188e70afaee2b3d 100644 (file)
--- a/Lib/test/test_generators.py
+++ b/Lib/test/test_generators.py
@@ -651,6 +651,17 @@ But this is fine:
 >>> list(f())
 [12, 666]
 
+>>> def f():
+...    yield
+Traceback (most recent call last):
+SyntaxError: invalid syntax
+
+>>> def f():
+...    if 0:
+...        yield
+Traceback (most recent call last):
+SyntaxError: invalid syntax
+
 >>> def f():
 ...     if 0:
 ...         yield 1
@@ -704,6 +715,28 @@ But this is fine:
 ...                 yield 2
 >>> type(f())
 <type 'None'>
+
+>>> def f():
+...     if 0:
+...         return
+...     if 0:
+...         yield 2
+>>> type(f())
+<type 'generator'>
+
+
+>>> def f():
+...     if 0:
+...         lambda x:  x        # shouldn't trigger here
+...         return              # or here
+...         def f(i):
+...             return 2*i      # or here
+...         if 0:
+...             return 3        # but *this* sucks (line 8)
+...     if 0:
+...         yield 2             # because it's a generator
+Traceback (most recent call last):
+SyntaxError: 'return' with argument inside generator (<string>, line 8)
 """
 
 __test__ = {"tut":      tutorial_tests,

diff --git a/Python/compile.c b/Python/compile.c
index e82c34c6132486b255c585457da966b5f9a8e31a..92322fcbd5a8396eb6c88b643362907418701124 100644 (file)
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -2876,6 +2876,45 @@ is_constant_false(struct compiling *c, node *n)
        return 0;
 }
 
+
+/* Look under n for a return stmt with an expression.
+ * This hack is used to find illegal returns under "if 0:" blocks in
+ * functions already known to be generators (as determined by the symtable
+ * pass).
+ * Return the offending return node if found, else NULL.
+ */
+static node *
+look_for_offending_return(node *n)
+{
+       int i;
+
+       for (i = 0; i < NCH(n); ++i) {
+               node *kid = CHILD(n, i);
+
+               switch (TYPE(kid)) {
+                       case classdef:
+                       case funcdef:
+                       case lambdef:
+                               /* Stuff in nested functions & classes doesn't
+                                  affect the code block we started in. */
+                               return NULL;
+
+                       case return_stmt:
+                               if (NCH(kid) > 1)
+                                       return kid;
+                               break;
+
+                       default: {
+                               node *bad = look_for_offending_return(kid);
+                               if (bad != NULL)
+                                       return bad;
+                       }
+               }
+       }
+
+       return NULL;
+}                      
+
 static void
 com_if_stmt(struct compiling *c, node *n)
 {
@@ -2886,8 +2925,24 @@ com_if_stmt(struct compiling *c, node *n)
        for (i = 0; i+3 < NCH(n); i+=4) {
                int a = 0;
                node *ch = CHILD(n, i+1);
-               if (is_constant_false(c, ch))
+               if (is_constant_false(c, ch)) {
+                       /* We're going to skip this block.  However, if this
+                          is a generator, we have to check the dead code
+                          anyway to make sure there aren't any return stmts
+                          with expressions, in the same scope. */
+                       if (c->c_flags & CO_GENERATOR) {
+                               node *p = look_for_offending_return(n);
+                               if (p != NULL) {
+                                       int savelineno = c->c_lineno;
+                                       c->c_lineno = p->n_lineno;
+                                       com_error(c, PyExc_SyntaxError,
+                                               "'return' with argument "
+                                               "inside generator");
+                                       c->c_lineno = savelineno;
+                               }
+                       }
                        continue;
+               }
                if (i > 0)
                        com_addoparg(c, SET_LINENO, ch->n_lineno);
                com_node(c, ch);
@@ -4840,7 +4895,10 @@ symtable_add_def_o(struct symtable *st, PyObject *dict,
 
 #define symtable_add_use(ST, NAME) symtable_add_def((ST), (NAME), USE)
 
-/* Look for a yield stmt under n.  Return 1 if found, else 0. */
+/* Look for a yield stmt under n.  Return 1 if found, else 0.
+   This hack is used to look inside "if 0:" blocks (which are normally
+   ignored) in case those are the only places a yield occurs (so that this
+   function is a generator). */
 static int
 look_for_yield(node *n)
 {
@@ -4853,6 +4911,7 @@ look_for_yield(node *n)
 
                case classdef:
                case funcdef:
+               case lambdef:
                        /* Stuff in nested functions and classes can't make
                           the parent a generator. */
                        return 0;