anchor.diff:          (format s sep-string))
         (pretty-print elm s)))
   
  -(defmethod pretty-print ((element special-value) s)
  -  ;; ??? Would a hash table make more sense here?
  -  (ecase (special-value-symbol element)
  -    (:this "this")
  -    (:null "null")
  -    (:true "true")
  -    (:false "false")
  -    (:undefined "undefined")))
  -
  -(defmethod pretty-print ((element identifier) s)
  -  (format s "~A" (identifier-name element)))
  -
  -(defmethod pretty-print ((element number) s)
  -  (format s "~D" (number-value element)))
  -
  -(defmethod pretty-print ((element string-literal) s)
  -  (format s "~S" (string-literal-value element)))
  -
  -(defmethod pretty-print ((element array-literal) s)
  +(defmethod pretty-print ((elm special-value) s)
  +  (if (find (special-value-symbol elm) *keyword-symbols*)
  +    (format s "~A" (string-downcase (special-value-symbol elm)))
  +    (error "Unknown special value symbol ~S" (special-value-symbol elm))))
  +   
  +(defmethod pretty-print ((elm identifier) s)
  +  (format s "~A" (identifier-name elm)))
  +
  +(defmethod pretty-print ((elm numeric-literal) s)
  +  (format s "~D" (numeric-literal-value elm)))
  +
  +(defmethod pretty-print ((elm string-literal) s)
  +  (format s "~S" (string-literal-value elm)))
  +
  +(defmethod pretty-print ((elm array-literal) s)
     (format s "[")
  -  (pretty-print-separated-list (array-literal-elements element) s)
  +  (pretty-print-separated-list (array-literal-elements elm) s)
     (format s "]"))
   
   ;; TODO May want some extra smarts here for things like class defns
   ;; ie, add newlines after each property if any of the properties are of type function-expression
  -(defmethod pretty-print ((element object-literal) s)
  +(defmethod pretty-print ((elm object-literal) s)
     (format s "{")
     (loop for idx upfrom 0
  -        for name/value in (object-literal-properties element)
  +        for name/value in (object-literal-properties elm)
           do
           (unless (zerop idx)
             (format s ", "))
  
positive.code:         (pretty-print (cdr name/value) s))
    (format s "}"))
  
  (defmethod pretty-print ((element new-expr) s)
    (cond
      ((null (new-expr-args element))
       (format s "new ~A" (new-expr-object-name element)))
      (t
       (format s "new ~A (")
       (pretty-print-separated-list (new-expr-args element) s))))
  
  (defmethod pretty-print ((element fn-call) s)
    (pretty-print (fn-call-fn element) s)
    (format s "(")
    (pretty-print-separated-list (fn-call-args element) s)
    (format s ")"))
  
  (defun printable-as-dot (string-literal-elm)
    (not (null (scan "^\\w+$" (string-literal-value string-literal-elm)))))
  
  (defmethod pretty-print ((element property-access) s)
    (pretty-print (property-access-target element) s)
    (cond
      ((printable-as-dot (property-access-field element))
       (format s ".~A" (string-literal-value (property-access-field element))))
      (t
       (format s "[")
       (pretty-print (property-access-field element) s)
       (format s "]"))))
  
  ;;HERE precedence handling
  ;(defmethod pretty-print ((element unary-operator) s)
  ;  (case (unary-operator-op-symbol element)
  ;    ((:post-decr :post-incr)
  ;     (pretty-print (unary-operator-arg) s)
  ;     ;;HERE
negative.code: ;; Print an abstract syntax tree for Javascript in a nicely-formatted fashion
  (in-package :jwacs)
  
  ;;;;; Rules for semicolon-termination
  ;;;;;;; The ideal situation
  ;;;
  ;;; There are two basic rules:
  ;;; 1. Calling `pretty-print` on a statement should always result in a semicolon-terminated statement
  ;;; 2. Calling `pretty-print` on any other source element (e.g., an expression) should /not/ result in
  ;;;    a semicolon-terminated line.
  ;;;
  ;;; This is (hopefully) an attainable ideal, but it will require us to change our parsing a little in order
  ;;; to be able to distinguish between (for example) expressions and expression statements.  (We'll
  ;;; probably just create an expression-statement source element that contains a single expression)
  ;;;
  ;;; I'm a little concerned that we may not be able to create all of the disambiguating source-element
  ;;; types because the parser itself may not be able to tell all of the cases apart.  I've omitted a few
  ;;; disambiguating rules from the parser that are in the standard grammar (things like "no newlines allowed
  ;;; between `return` and its argument"), because they are not expressible in a Lispworks's parser-generator
  ;;; grammar.  These omissions may have led to some extra ambiguity; certainly there is an awful lot of
  ;;; complaining when Lispworks is compiling the grammar.
  ;;;
  ;;;;;;; The actual situation
  ;;;
  ;;; For now, we assume that neither statements nor any other source element self-semicolon-terminates.
  ;;; The pretty-printer for blocks (and lists of statement) will just slap a semicolon after each
  ;;; statement minus some exceptions (if, while, for, function declarations, etc.).
  
  ;;;;; Indentation helpers
  (defparameter *indent-step* 2)
  (defvar *indent* 0)
  
  (defun fresh-line-indented (s)
    "start a new, indented line"
    (fresh-line s)
    (dotimes (n *indent*)
      (format s " ")))
  
  (defmacro with-indent (&body body)
    "Execute the contained forms with *indent* set one step deeper"
    `(let ((*indent* (+ *indent* *indent-step*)))
      ,@body))
  
  ;; When we print subordinate statements (as for a while or for loop), we want to indent
  ;; single statements, but not blocks (because blocks will do the indentation for us).
  ;; In those situations, use pretty-print-subordinate instead of pretty-print; it will
  ;; indent correctly depending upon the type of source-element that it receives.
  (defmethod pretty-print-subordinate ((elm block) s)
    (pretty-print elm s))
  
  (defmethod pretty-print-subordinate (elm s)
    (with-indent
      (fresh-line-indented s)
      (pretty-print elm s)))
  
  ;;;;; General helpers
  (defun pretty-print-separated-list (elm-list s &optional (sep-string ", "))
    (loop
        for idx upfrom 0
  