anchor.diff:  ;;;  (foo x y z)
   ;;; where the names x y z would be viewed as lisp variables.
   ;;;
  -;;; But if we use :SYMBOL-NAME instead, e.g.:
  +;;; But if we use :NAME instead, e.g.:
   ;;;
   ;;; (define-sw-parser-rule :FOO ()
  -;;;   (:tuple "foo" (1 :SYMBOL-NAME) (2 :SYMBOL-NAME) (3 :SYMBOL-NAME))
  +;;;   (:tuple "foo" (1 :NAME) (2 :NAME) (3 :NAME))
   ;;;   (foo 1 2 3)
   ;;;
   ;;; then after substitutions we'd get lisp forms such as
  
positive.code: 
  (define-sw-parser-rule :UNQUALIFIED-AMBIGUOUS-NAME ()
    (:anyof
     ;; maybe :NAME should be :SYMBOL-NAME
     ;; that would automatically rule out "=", "*", "/", "translate", etc.
     ((:tuple (1 :NAME)) (MetaSlang::mkUnQualifiedId 1))
     ((:tuple "_")       (MetaSlang::mkUnQualifiedId "_"))
     ))
  
  (define-sw-parser-rule :QUALIFIED-AMBIGUOUS-NAME ()
    (:anyof
     ;; maybe :NAME should be :SYMBOL-NAME
     ;; that would automatically rule out "=", "*", "/", "translate", etc.
     ((:tuple (1 :QUALIFIER) "." (2 :NAME)) (MetaSlang::mkQualifiedId-2 1 2))
     ((:tuple (1 :QUALIFIER) "." "_")       (MetaSlang::mkQualifiedId-2 1 "_"))
     ))
  
negative.code: ;;;       since dot is not legal after a TIGHT-EXPRESSION,
  ;;;       but the competing TWO-NAME-EXPRESSION may succeed.
  (define-sw-parser-rule :UNQUALIFIED-OP-REF ()
    (:anyof
     ;; so we can use "="  in expressions, e.g "A = B"
     ((:tuple "=")        (make-equality-fun       '(:|Equals|) ':left-lcb ':right-lcb))
     ((:tuple (1 :NAME))  (make-unqualified-op-ref 1            ':left-lcb ':right-lcb))
     ))
  
  ;;; ------------------------------------------------------------------------
  ;;;   NAME-DOT-NAME
  