anchor.diff:  
   (defun parse-assignment (lhs)
     (with-new-anchored-parse-tree (parse-tree-start-pos lhs) :set!
  -    (consume-token :identifier "=")
  +    (consume-token :punctuation "=")
       (list lhs (parse-expression))))
   
   ;; Precedence table:
  
positive.code:       (list args body))))
  
  (defun parse-lambda-args ()
    (if (tokenp :punctuation "(")
        (with-new-parse-tree :list
          (consume-token :punctuation "(")
          (prog1
              (parse-list #'parse-name '(:punctuation ","))
            (consume-token :punctuation ")")))
        (parse-name)))
  
  (defun parse-list (item-parser separator)
    (let (result)
      (loop
         (push (funcall item-parser) result)
         (unless (apply #'tokenp separator)
           (return))
         (apply #'consume-token separator))
      (reverse result)))
  
  (defun parse-name ()
    (require-token :identifier nil)
    (with-new-parse-tree :name
      (prog1
          (token-content (current-token))
  
negative.code:       (parse-unary-minus-term)))
  
  (defun parse-unary-minus-term ()
    (cond ((tokenp :number) (parse-number))
          ((tokenp :string) (parse-literal-string))
          (t (parse-identifier-or-call-or-ref))))
  
  (defun parse-identifier-or-call-or-ref (&optional forced-start)
  