anchor.diff:            (collect-type-form
              (make-structure-class-forms type slots non-lazy-fields lazy-fields)))
         (collect-form `(record-protobuf-object ',type ,message :message))
  +      ;; Group can never be a top level element.
         `(progn
            define-group
            ,message
  
positive.code:              (appendf (proto-fields extends) (list field))
               (appendf (proto-extended-fields extends) (list field))))))
        (collect-form `(record-protobuf-object ',type ,extends :message))
        `(progn ,@forms))))
  
  (defun index-within-extensions-p (index message)
    (let ((extensions (proto-extensions message)))
  
negative.code:   (let ((expansion (type-expand enum-type)))
      (check-type expansion (cons (eql member) list))
      (rest expansion)))
  
  (defvar *enum-forms* nil
    "The enum forms have to be evaluated first as they become types
  for messages and sadly the messages can be defined before the enums.")
  
  (defun create-progn-with-enum-forms-if-top-level (top-level-form-p &rest lists)
    "Create the output progn form for a define statement which may be top-level
  and have an enum inside of it. If it is top level output the internal enums
  before the rest of the forms, otherwise just output the forms collected.
  Parameters:
    TOP-LEVEL-FORM-P: Bool stating whether this is top-level or not.
    LISTS: The lists that have been collected in the defining form for output."
    (let (out-list)
      ;; Our foolish version of one-level flatten
      (dolist (list (reverse lists))
        (dolist (inner-list (reverse list))
          (push inner-list out-list)))
  
      (if (and top-level-form-p *enum-forms*)
          (let ((output
                 `(progn ,@*enum-forms* ,@out-list)))
            (setf *enum-forms* nil)
            output)
          `(progn ,@out-list))))
  
  (defmacro define-enum (type (&key name conc-name alias-for)
                         &body values)
  