namedlambda: auto-name with source location info if no name candidate

Technologicat · Technologicat · commit e4e231374920 · 2021-05-10T20:06:10.000+03:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -78,6 +78,7 @@ The same applies if you need the macro parts of `unpythonic` (i.e. import anythi
 
 - **Miscellaneous.**
   - `with namedlambda` now understands the walrus operator, too. In the construct `f := lambda ...: ...`, the lambda will get the name `f`. (Python 3.8 and later.)
+  - `with namedlambda` now auto-names lambdas that don't have a name candidate using their source location info, if present. This makes it easy to see in a stack trace where some particular lambda was defined.
   - Add `unpythonic.dispatch.generic_addmethod`: add methods to a generic function defined elsewhere.
   - All documentation files now have a quick navigation section to skip to another part of the docs. (For all except the README, it's at the top.)
   - Python 3.8 and 3.9 support added.
diff --git a/unpythonic/syntax/lambdatools.py b/unpythonic/syntax/lambdatools.py
@@ -263,10 +263,13 @@ def iscurrywithfinallambda(tree):
     currycall_name = "currycall"
     iscurryf = lambda name: name in ("curryf", "curry")  # auto or manual curry in a "with autocurry"
     def isautocurrywithfinallambda(tree):
+        # "currycall(..., curryf(lambda ...: ...))"
         if not (type(tree) is Call and isx(tree.func, currycall_name) and tree.args and
                 type(tree.args[-1]) is Call and isx(tree.args[-1].func, iscurryf)):
             return False
-        return type(tree.args[-1].args[-1]) is Lambda
+        curryf_callnode = tree.args[-1]
+        lastarg = curryf_callnode.args[-1]
+        return type(lastarg) is Lambda
 
     def iscallwithnamedargs(tree):
         return type(tree) is Call and tree.keywords
@@ -279,11 +282,12 @@ def nameit(myname, tree):
         # The `has_deco` check ignores any already named lambdas.
         d = is_decorated_lambda(tree, mode="any") and not has_deco(["namelambda"], tree)
         c = iscurrywithfinallambda(tree)
-        # this matches only during the second pass (after "with autocurry" has expanded)
+        # This matches only during the second pass (after "with autocurry" has expanded)
         # so it can't have namelambda already applied
         if isautocurrywithfinallambda(tree):  # "currycall(..., curryf(lambda ...: ...))"
             match = True
             thelambda = tree.args[-1].args[-1]
+            # --> "currycall(..., (namelambda(myname))(curryf(lambda ...: ...)))"
             tree.args[-1].args[-1] = q[h[namelambda](u[myname])(a[thelambda])]
         elif type(tree) is Lambda or d or c:
             match = True
@@ -375,7 +379,30 @@ def transform(self, tree):
     newbody = dyn._macro_expander.visit(newbody)
 
     # inside out: transform in expanded autocurry
-    return NamedLambdaTransformer().visit(newbody)
+    newbody = NamedLambdaTransformer().visit(newbody)
+
+    # v0.15.0+: Finally, auto-name any still anonymous `lambda` with source location info.
+    # We must perform this in a separate pass so that expanded autocurry invocations
+    # are transformed correctly first.
+    class NamedLambdaFinalizationTransformer(ASTTransformer):
+        def transform(self, tree):
+            # Recurse into the lambda body in already named lambdas.
+            if is_decorated_lambda(tree, mode="any") and has_deco(["namelambda"], tree):
+                decorator_list, thelambda = destructure_decorated_lambda(tree)
+                thelambda.body = self.visit(thelambda.body)
+                return tree
+            elif type(tree) is Lambda:
+                if hasattr(tree, "lineno"):
+                    thename = f"<lambda at {dyn._macro_expander.filename}:{tree.lineno}>"
+                    tree, thelambda, match = nameit(thename, tree)
+                    if match:
+                        thelambda.body = self.visit(thelambda.body)
+                    else:
+                        tree = self.visit(tree)
+                return tree
+            return self.generic_visit(tree)
+    return NamedLambdaFinalizationTransformer().visit(newbody)
+
 
 # The function `f` is adapted from the `f` macro in `macropy.quick_lambda`,
 # stripped into a bare syntax transformer., and then the `@Walker` inside
diff --git a/unpythonic/syntax/tests/test_lambdatools.py b/unpythonic/syntax/tests/test_lambdatools.py
@@ -70,12 +70,12 @@ def foo(func1, func2):
                 func2=lambda x: x**2)  # function call with named arg: name as "func2"
 
             def bar(func1, func2):
-                test[func1.__name__ == "<lambda>"]
-                test[func2.__name__ == "<lambda>"]
-            bar(lambda x: x**2, lambda x: x**2)  # no naming when passed positionally
+                test[func1.__name__.startswith("<lambda at")]
+                test[func2.__name__.startswith("<lambda at")]
+            bar(lambda x: x**2, lambda x: x**2)  # name by source location info only when passed positionally
 
             def baz(func1, func2):
-                test[func1.__name__ == "<lambda>"]
+                test[func1.__name__.startswith("<lambda at")]
                 test[func2.__name__ == "func2"]
             baz(lambda x: x**2, func2=lambda x: x**2)
 
