anchor.diff:                           (collect-nslot nslot))
                          (when rslot
                            (collect-rslot rslot))
  -                       (when oneofslot
  -                         (collect-oneofslot oneofslot)))))))
  +                       (when oneof-slot
  +                         (collect-oneof-slot oneof-slot)))))))
         (let* ((rslots  (delete-duplicates rslots :key #'first))
                (rfields (mapcar #'first  rslots))
                (rtemps  (mapcar #'second rslots))
  -             (oneofslots (delete-duplicates oneofslots :test #'string= :key #'symbol-name))
  +             (oneof-slots (delete-duplicates oneof-slots :test #'string= :key #'symbol-name))
                (lisp-type (or (proto-alias-for message) (proto-class message)))
                (lisp-class (find-class lisp-type nil))
                (constructor (or constructor
  
positive.code:                       ;; For tracking repeated slots that will need to be reversed
                        (rslots collect-rslot)
                        ;; For tracking oneof slots
                        (oneofslots collect-oneofslot))
        (flet ((include-field (field)
                 (or (eq include-fields :all)
                     (member (proto-external-field-name field)
  
negative.code:         (dolist (field fields)
            (when (and (include-field field)
                       (not (skip-field field)))
              (multiple-value-bind (tags deserializers nslot rslot oneof-slot)
                  (generate-field-deserializer message field vbuf vidx :raw-p raw-p)
                (assert tags)
                (assert deserializers)
  