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:                            #+sbcl`(make-instance ',lisp-type)
                             #-sbcl`(funcall (get-constructor-name ',lisp-type)))
                       ;; oneofs
                       ,@(loop for temp in oneofslots
                               for mtemp = (slot-value-to-slot-name-symbol temp)
                               nconc (list (intern (string mtemp) :keyword) temp))
                       ;; nonrepeating slots
  
negative.code:                     (type array-index ,vidx ,vlim))
             (let (,@(loop for slot in nslots
                           collect `(,slot ,missing-value))
                   ,@(loop for oneof-slot in oneof-slots
                           collect `(,oneof-slot (make-instance 'oneof)))
                   ,@rtemps)
               (loop
                 (multiple-value-setq (tag ,vidx)
  