pondering about nested autorefs

Technologicat · Technologicat · commit 34f0a56d5f9e · 2019-04-15T10:06:30.000+03:00
diff --git a/unpythonic/syntax/autoref.py b/unpythonic/syntax/autoref.py
@@ -7,10 +7,12 @@
 from macropy.core.walkers import Walker
 
 from ..dynassign import dyn
+from ..lazyutil import force1
 
 # TODO: suppport Attribute, Subscript in autoref
 # TODO: support nested autorefs
-# Consider:
+# We need something like::
+#
 #   with autoref(o):
 #       x        # --> (o.x if hasattr(o, "x") else x)
 #       x.a      # --> (o.x.a if hasattr(o, "x") else x.a)
@@ -23,6 +25,45 @@
 #          o     # --> (p.o if hasattr(p, "o") else o)
 #          o.x   # --> (p.o.x if hasattr(p, "o") else o.x)
 #          o[s]  # --> (p.o[s] if hasattr(p, "o") else o[s])
+#
+# One possible clean-ish implementation is::
+#
+#   with autoref(o):
+#       x        # --> (lambda _ar271: _ar271[1] if _ar271[0] else x)(_autoref_resolve((o, "x")))
+#       x.a      # --> ((lambda _ar271: _ar271[1] if _ar271[0] else x)(_autoref_resolve((o, "x")))).a
+#       x[s]     # --> ((lambda _ar271: _ar271[1] if _ar271[0] else x)(_autoref_resolve((o, "x"))))[s]
+#       o        # --> o
+#       with autoref(p):
+#          # the outer autoref just needs to insert its obj to the arglist
+#          x     # --> (lambda _ar314: _ar314[1] if _ar314[0] else x)(*_autoref_resolve((p, o, "x")))
+#          x.a   # --> ((lambda _ar314: _ar314[1] if _ar314[0] else x)(*_autoref_resolve((p, o, "x"))).a
+#          x[s]  # --> ((lambda _ar314: _ar314[1] if _ar314[0] else x)(*_autoref_resolve((p, o, "x")))[s]
+#          # these are transformed when the **outer** autoref transforms
+#          o     # --> (lambda _ar314: _ar314[1] if _ar314[0] else o)(*_autoref_resolve((p, "o")))
+#          o.x   # --> ((lambda _ar314: _ar314[1] if _ar314[0] else o)(*_autoref_resolve((p, "o")))).x
+#          o[s]  # --> ((lambda _ar314: _ar314[1] if _ar314[0] else o)(*_autoref_resolve((p, "o"))))[s]
+#
+# The lambda is needed, because the lexical-variable lookup for ``x`` must occur at the use site.
+# We could modify ``_autoref_resolve`` to look in ``locals()``, too (and pass it in), but that
+# leads to an unnecessary performance hit.
+#
+# Recall the blocks expand from inside out. Here ``_ar*`` are gensyms. A single unique name
+# for the parameter of the lambdas would be sufficient, but this is easier to arrange.
+#
+# In ``_autoref_resolve``, we use a single args parameter to avoid dealing with ``*args``
+# when analyzing the Call node, thus avoiding much special-case code for the AST differences
+# between Python 3.4 and 3.5+.
+#
+# In reality, we also capture-and-assign the autoref'd expr into a gensym'd variable (instead of referring
+# to ``o`` and ``p`` directly), so that arbitrary expressions can be autoref'd without giving them
+# a name in user code.
+
+def _autoref_resolve(args):
+    *objs, s = args
+    for o in objs:
+        if hasattr(o, s):
+            return True, force1(getattr(o, s))
+    return False, None
 
 def autoref(block_body, args):
     assert len(args) == 1, "expected exactly one argument, the object to implicitly reference"
diff --git a/unpythonic/syntax/lazify.py b/unpythonic/syntax/lazify.py
@@ -260,8 +260,10 @@ def transform_starred(tree, dstarred=False):
                     thelambda.body = rec(thelambda.body)
             # namelambda() is used by let[] and do[]
             # Lazy() is a strict function, takes a lambda, constructs a Lazy object
+            # _autoref_resolve doesn't need any special handling
             elif isdo(tree) or is_decorator(tree.func, "namelambda") or \
-               any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, isLazy):
+               any(isx(tree.func, s) for s in _ctorcalls_all) or isx(tree.func, isLazy) or \
+               isx(tree.func, "_autoref_resolve"):
                 # here we know the operator (.func) to be one of specific names;
                 # don't transform it to avoid confusing lazyrec[] (important if this
                 # is an inner call in the arglist of an outer, lazy call, since it
