Symbol macros shadowed by functions under dwim.

* eval.c (lookup_symac_lisp1, expand_lisp1,
expand_forms_lisp1): New static functions.
(expand): Handle dwim's arguments via
expand_forms_lisp1, rather than as a generic
compound form.

* txr.1: Revised text in several places to clarify
this expansion rule.

3 files changed, 125 insertions, 20 deletions

diff --git a/ChangeLog b/ChangeLog
index 60010033..ab7fba99 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,16 @@
+2015-02-04  Kaz Kylheku  <kaz@kylheku.com>
+
+	Symbol macros shadowed by functions under dwim.
+
+	* eval.c (lookup_symac_lisp1, expand_lisp1,
+	expand_forms_lisp1): New static functions.
+	(expand): Handle dwim's arguments via
+	expand_forms_lisp1, rather than as a generic
+	compound form.
+
+	* txr.1: Revised text in several places to clarify
+	this expansion rule.
+
 2015-02-01  Kaz Kylheku  <kaz@kylheku.com>
 
 	Version 103
diff --git a/eval.c b/eval.c
index 12468562..9def9db9 100644
--- a/eval.c
+++ b/eval.c
@@ -275,6 +275,32 @@ static val lookup_symac(val menv, val sym)
   }
 }
 
+static val lookup_symac_lisp1(val menv, val sym)
+{
+  if (nilp(menv)) {
+    return gethash(top_smb, sym);
+  } else  {
+    type_check(menv, ENV);
+
+    /* Of course, we are not looking for symbol macros in the operator macro
+     * name space.  Rather, the object of the lookup rule implemented by this
+     * function is to allow lexical function bindings to shadow symbol macros.
+     */
+    {
+      val vbinding = assoc(sym, menv->e.vbindings);
+      if (vbinding) {
+        return (cdr(vbinding) == special_s) ? nil : vbinding;
+      } else {
+        val fbinding = assoc(sym, menv->e.fbindings);
+        if (fbinding && cdr(fbinding) == special_s)
+          return nil;
+      }
+
+      return lookup_symac(menv->e.up_env, sym);
+    }
+  }
+}
+
 static val lexical_var_p(val menv, val sym)
 {
   if (nilp(menv)) {
@@ -2188,6 +2214,41 @@ val expand_forms(val form, val menv)
   }
 }
 
+static val expand_lisp1(val form, val menv)
+{
+tail:
+  if (bindable(form)) {
+    val symac_bind = lookup_symac_lisp1(menv, form);
+
+    if (symac_bind) {
+      val symac = cdr(symac_bind);
+      if (symac == form)
+        return form;
+      form = rlcp_tree(symac, form);
+      goto tail;
+    }
+    return form;
+  }
+
+  return expand(form, menv);
+}
+
+static val expand_forms_lisp1(val form, val menv)
+{
+  if (atom(form)) {
+    return form;
+  } else {
+    val f = car(form);
+    val r = cdr(form);
+    val ex_f = expand_lisp1(f, menv);
+    val ex_r = expand_forms_lisp1(r, menv);
+
+    if (ex_f == f && ex_r == r)
+      return form;
+    return rlcp(cons(ex_f, ex_r), form);
+  }
+}
+
 static val expand_cond_pairs(val form, val menv)
 {
   if (atom(form)) {
@@ -2918,6 +2979,13 @@ tail:
       return expand_macrolet(form, menv);
     } else if (sym == symacrolet_s) {
       return expand_symacrolet(form, menv);
+    } else if (sym == dwim_s) {
+      val args = rest(form);
+      val args_ex = expand_forms_lisp1(args, menv);
+
+      if (args == args_ex)
+        return form;
+      return rlcp(cons(sym, args_ex), form);
     } else if ((macro = lookup_mac(menv, sym))) {
       val mac_expand = expand_macro(form, macro, menv);
       if (mac_expand == form)
diff --git a/txr.1 b/txr.1
index 64108b3d..10046d54 100644
--- a/txr.1
+++ b/txr.1
@@ -10385,30 +10385,34 @@ and vice versa.
 If a symbol is bound to both a function and variable in the global namespace,
 then the variable binding is favored.
 
-Macros do not participate in the special scope conflation. This is apparent
-in two ways. Firstly, the space of symbol macros is not folded together with
-the space of regular macros. An argument of
+Macros do not participate in the special scope conflation, with one
+exception. What this means is that the space of symbol macros is not folded
+together with the space of regular macros. An argument of
 .code dwim
 that is a symbol might be
 symbol macro, variable or function, but it cannot be interpreted as the name of
-a regular macro. Secondly, function bindings cannot shadow symbol macros. If a
-function is defined in an inner scope relative to a symbol macro for the
-same symbol, that symbol macro still hides the function when it appears in
-a
+a regular macro.
+
+The exception is this: from the perspective of a
 .code dwim
-form. Symbol macros are expanded without any consideration for the
+form, function bindings can shadow symbol macros. If a
+function binding is defined in an inner scope relative to a symbol macro for
+the same symbol,
+using
+.code flet
+or
+.codn labels ,
+the function hides the symbol macro. In other words, when
+macro expansion processes an argument of a
 .code dwim
-operator, which is not treated specially by the expansion phase.
-
-Thus, the following is invalid:
-
-.cblk
-[let ((f (+ 2 2))) f]
-.cble
-
-the expression looks for a function or variable called
-.codn let ,
-which does not exist.
+form, and that argument is a symbol, it is treated specially
+in order to provide a consistent name lookup behavior. If the innermost
+binding for that symbol is a function binding, it refers to that
+function binding, even if a more outer symbol macro binding exists,
+and so the symbol is not expanded using the symbol macro.
+By contrast, in an ordinary form, a symbolic argument never resolves
+to a function binding. The symbol refers to either a symbol macro or a
+variable, whichever is nested closer.
 
 How many arguments are required by the
 .code dwim
@@ -11692,11 +11696,22 @@ Note that
 and
 .code flet
 are properly scoped with regard to macros.
-During macro expansion, they shadow, macros defined by
+During macro expansion, function bindings introduced by these
+macro operators shadow macros defined by
 .code macrolet
 and
 .codn defmacro .
 
+Furthermore, function bindings introduced by
+.code labels
+and
+.code flet
+also shadow symbol macros defined by
+.codn symacrolet ,
+when those symbol macros occur as arguments of a
+.code dwim
+form.
+
 See also: the
 .code macrolet
 operator.
@@ -26117,6 +26132,15 @@ constructs will see whichever of the two bindings is more inner,
 even though the bindings are active in completely separate phases of
 processing.
 
+From the perspective of the arguments of a
+.code dwim
+form, lexical function bindings also shadow symbol macros.
+This is consistent with the Lisp-1-style name resolution which
+applies inside a
+.code dwim
+form. Of course, lexical operator macros do not shadow
+symbol macros under any circumstances.
+
 .coNP Operator @ tree-bind
 .synb
 .mets (tree-bind < macro-style-params < expr << form *)