fixed nonlocal scoping for deeper inner functions; also check decorators for local variables

Author: craigbarratt

custom_components/pyscript/eval.py

@@ -563,7 +563,9 @@ async def resolve_nonlocals(self, ast_ctx):
         var_names = set(args)
         local_names = set(args)
         for stmt in self.func_def.body:
-            self.has_closure = self.has_closure or isinstance(stmt, ast.FunctionDef)
+            self.has_closure = self.has_closure or isinstance(
+                stmt, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)
+            )
             var_names = var_names.union(
                 await ast_ctx.get_names(
                     stmt, nonlocal_names=nonlocal_names, global_names=global_names, local_names=local_names,
@@ -1839,7 +1841,7 @@ async def get_target_names(self, lhs):
             names.add(lhs.id)
         return names
 
-    async def get_names_set(self, arg, names, nonlocal_names=None, global_names=None, local_names=None):
+    async def get_names_set(self, arg, names, nonlocal_names, global_names, local_names):
         """Recursively find all the names mentioned in the AST tree."""
 
         cls_name = arg.__class__.__name__
@@ -1891,51 +1893,38 @@ async def get_names_set(self, arg, names, nonlocal_names=None, global_names=None
                         local_names.add(handler.name)
                         names.add(handler.name)
             elif cls_name == "Call":
-                await self.get_names_set(
-                    arg.func,
-                    names,
-                    nonlocal_names=nonlocal_names,
-                    global_names=global_names,
-                    local_names=local_names,
-                )
+                await self.get_names_set(arg.func, names, nonlocal_names, global_names, local_names)
                 for this_arg in arg.args:
-                    await self.get_names_set(
-                        this_arg,
-                        names,
-                        nonlocal_names=nonlocal_names,
-                        global_names=global_names,
-                        local_names=local_names,
-                    )
+                    await self.get_names_set(this_arg, names, nonlocal_names, global_names, local_names)
                 return
             elif cls_name in {"FunctionDef", "ClassDef", "AsyncFunctionDef"}:
                 local_names.add(arg.name)
                 names.add(arg.name)
+                for dec in arg.decorator_list:
+                    await self.get_names_set(dec, names, nonlocal_names, global_names, local_names)
+                #
+                # find unbound names from the body of the function or class
+                #
+                inner_global, inner_names, inner_local = set(), set(), set()
+                for child in arg.body:
+                    await self.get_names_set(child, inner_names, None, inner_global, inner_local)
+                for name in inner_names:
+                    if name not in inner_local and name not in inner_global:
+                        names.add(name)
                 return
             elif cls_name == "Delete":
                 for arg1 in arg.targets:
                     if isinstance(arg1, ast.Name):
                         local_names.add(arg1.id)
         for child in ast.iter_child_nodes(arg):
-            await self.get_names_set(
-                child,
-                names,
-                nonlocal_names=nonlocal_names,
-                global_names=global_names,
-                local_names=local_names,
-            )
+            await self.get_names_set(child, names, nonlocal_names, global_names, local_names)
 
     async def get_names(self, this_ast=None, nonlocal_names=None, global_names=None, local_names=None):
         """Return set of all the names mentioned in our AST tree."""
         names = set()
         this_ast = this_ast or self.ast
         if this_ast:
-            await self.get_names_set(
-                this_ast,
-                names,
-                nonlocal_names=nonlocal_names,
-                global_names=global_names,
-                local_names=local_names,
-            )
+            await self.get_names_set(this_ast, names, nonlocal_names, global_names, local_names)
         return names
 
     def parse(self, code_str, filename=None, mode="exec"):

tests/test_decorators.py

@@ -133,9 +133,8 @@ def func3():
     pyscript.done = seq_num
 
 def repeat(num_times):
+    num_times += 0
     def decorator_repeat(func):
-        nonlocal num_times
-
         @state_trigger("pyscript.var1 == '4'")
         def wrapper_repeat(*args, **kwargs):
             for _ in range(num_times):
@@ -167,8 +166,6 @@ def startup_test():
 
 def add_state_trig(value):
     def dec_add_state_trig(func):
-        nonlocal value
-
         @state_trigger(f"pyscript.var1 == '{value}'")
         def dec_add_state_wrapper(*args, **kwargs):
             return func(*args, **kwargs)

tests/test_unit_eval.py

@@ -585,6 +585,22 @@ def foo(cnt):
     ],
     [
         """
+def f1(x, y, z):
+    def f2():
+        y = 5
+        def f3():
+            nonlocal x, y
+            x += 1
+            y += 1
+            return x + y + z
+        return f3()
+    return [x, y, z, f2()]
+f1(10, 20, 30)
+""",
+        [10, 20, 30, 47],
+    ],
+    [
+        """
 def twice(func):
     def twice_func(*args, **kwargs):
         func(*args, **kwargs)
@@ -624,7 +640,6 @@ def twice_func(*args, **kwargs):
 
 def repeat(num_times):
     def decorator_repeat(func):
-        nonlocal num_times
         def wrapper_repeat(*args, **kwargs):
             for _ in range(num_times):
                 value = func(*args, **kwargs)
@@ -657,6 +672,37 @@ def foo2():
     ],
     [
         """
+def repeat(num_times):
+    def decorator_repeat(func):
+        def wrapper_repeat(*args, **kwargs):
+            for _ in range(num_times):
+                value = func(*args, **kwargs)
+            return value
+        return wrapper_repeat
+    return decorator_repeat
+
+def repeat2(num_times):
+    def decorator_repeat(func):
+        nonlocal num_times
+        def wrapper_repeat(*args, **kwargs):
+            for _ in range(num_times):
+                value = func(*args, **kwargs)
+            return value
+        return wrapper_repeat
+    return decorator_repeat
+
+x = 0
+def func(incr):
+    global x
+    x += incr
+    return x
+
+[repeat(3)(func)(10), repeat2(3)(func)(20)]
+""",
+        [30, 90],
+    ],
+    [
+        """
 def foo():
     global f_bar
     def f_bar():