4 files changed, 65 insertions, 23 deletions

diff --git a/Lib/test/output/test_grammar b/Lib/test/output/test_grammar
index 319177c..c69697d 100644
--- a/Lib/test/output/test_grammar
+++ b/Lib/test/output/test_grammar
@@ -38,7 +38,6 @@ continue + try/finally ok
 return_stmt
 raise_stmt
 import_stmt
-SyntaxError expected for "def f(): from sys import *"
 global_stmt
 exec_stmt
 if_stmt
diff --git a/Lib/test/output/test_scope b/Lib/test/output/test_scope
index 17e5cb8..0535e26 100644
--- a/Lib/test/output/test_scope
+++ b/Lib/test/output/test_scope
@@ -12,3 +12,4 @@ test_scope
 11. unoptimized namespaces
 12. lambdas
 13. UnboundLocal
+14. complex definitions
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index 5865e8c..53ae070 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -386,7 +386,6 @@ import time, sys
 from time import time
 from sys import *
 from sys import path, argv
-check_syntax("def f(): from sys import *")
 
 print 'global_stmt' # 'global' NAME (',' NAME)*
 def f():
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index 4f3c1ff..a58be00 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -185,44 +185,64 @@ def check_syntax(s):
     else:
         raise TestFailed
 
-# XXX for now, it is easiest to call this a syntax error:
-# explicit is better than implicit...
-test1 = \
-"""def unoptimized_clash1(strip):
+check_syntax("""def unoptimized_clash1(strip):
     def f(s):
         from string import *
         return strip(s) # ambiguity: free or local
     return f
-"""
-check_syntax(test1)
+""")
 
-# a little harder to reject this one, but possible...
-test2 = \
-"""def unoptimized_clash2():
+check_syntax("""def unoptimized_clash2():
     from string import *
     def f(s):
         return strip(s) # ambiguity: global or local
     return f
-"""
-# check_syntax(test2)
+""")
 
-# XXX could allow this for exec with const argument, but what's the point
-test3 = \
-"""def error(y):
+check_syntax("""def unoptimized_clash2():
+    from string import *
+    def g():
+        def f(s):
+            return strip(s) # ambiguity: global or local
+        return f
+""")
+
+# XXX could allow this for exec with const argument, but what's the point 
+check_syntax("""def error(y):
     exec "a = 1"
     def f(x):
         return x + y
     return f
-"""
-check_syntax(test3)
+""")
 
-test4 = \
-"""def f(x):
+check_syntax("""def f(x):
     def g():
         return x
-    del x
-"""
-check_syntax(test4)
+    del x # can't del name
+""")
+
+check_syntax("""def f():
+    def g():
+         from string import *
+         return strip # global or local?
+""")            
+
+# and verify a few cases that should work
+
+def noproblem1():
+    from string import *
+    f = lambda x:x
+
+def noproblem2():
+    from string import *
+    def f(x):
+        return x + 1
+
+def noproblem3():
+    from string import *
+    def f(x):
+        global y
+        y = x
 
 print "12. lambdas"
 
@@ -275,3 +295,26 @@ except UnboundLocalError:
     pass
 else:
     raise TestFailed
+
+print "14. complex definitions"
+
+def makeReturner(*lst):
+    def returner():
+        return lst
+    return returner
+ 
+verify(makeReturner(1,2,3)() == (1,2,3))
+ 
+def makeReturner2(**kwargs):
+    def returner():
+        return kwargs
+    return returner
+
+verify(makeReturner2(a=11)()['a'] == 11)
+
+def makeAddPair((a, b)):
+    def addPair((c, d)):
+        return (a + c, b + d)
+    return addPair
+
+verify(makeAddPair((1, 2))((100, 200)) == (101,202))