anchor.diff:  ;; 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)
  +;; TODO The semicolon keyword will disappear once we are dealing correctly with semicolon termination
  +(defmethod pretty-print-subordinate ((elm block) s &key semicolon)
  +  (declare (ignore semicolon))
     (pretty-print elm s))
   
  -(defmethod pretty-print-subordinate (elm s)
  +(defmethod pretty-print-subordinate (elm s &key semicolon)
     (with-indent
       (fresh-line-indented s)
  -    (pretty-print elm s)))
  +    (pretty-print elm s)
  +    (if semicolon
  +      (format s ";"))))
   
   ;;;;; General helpers
   (defun pretty-print-separated-list (elm-list s &optional (sep-string ", "))
  
positive.code: {
    baz;
  }")
  
         ))))
  
negative.code: ;;;
  ;;; 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
  