anchor.diff:                                                  (and (not (proto-lazy-p field))
                                                        reader))
                                        (list object)))
  -                         ;; To serialize an embedded message, first say that it's
  -                         ;; a string, then encode its size, then serialize its fields
  -                         (iincf size (encode-uint32 tag buffer))
  -                         (let ((submessage-size 0))
  -                           (with-placeholder (buffer)
  -                             (if custom-serializer
  -                                 (iincf submessage-size
  -                                        (funcall custom-serializer v buffer))
  -                                 (dolist (f (proto-fields msg))
  -                                   (iincf submessage-size (emit-field v f buffer))))
  -                             (iincf size (+ (backpatch submessage-size)
  -                                            submessage-size)))))))
  +                              ;; To serialize an embedded message, first say that it's
  +                              ;; a string, then encode its size, then serialize its fields
  +                              (iincf size (encode-uint32 tag buffer))
  +                              (let ((submessage-size 0))
  +                                (with-placeholder (buffer)
  +                                  (if custom-serializer
  +                                      (iincf submessage-size
  +                                             (funcall custom-serializer v buffer))
  +                                      (dolist (f (proto-fields msg))
  +                                        (iincf submessage-size (emit-field v f buffer))))
  +                                  (iincf size (+ (backpatch submessage-size)
  +                                                 submessage-size)))))))
                    size)
                   ((typep msg 'protobuf-enum)
                    ;; 'proto-packed-p' of enum types returns nil,
  
positive.code:                       (protobuf-enum-values msg) index buffer)
                       (let ((tag (make-tag $wire-type-varint index)))
                         (doseq (v (read-slot object slot reader) size)
                           (iincf size
                                  (serialize-enum v (protobuf-enum-values msg) tag buffer))))))
                  ((typep msg 'protobuf-type-alias)
                   (let* ((type (proto-proto-type msg))
                          (tag  (make-tag type index)))
                     (doseq (v (read-slot object slot reader) size)
                       (let ((v (funcall (proto-serializer msg) v)))
                         (iincf size (serialize-prim v type tag buffer))))))
                  (t (undefined-field-type "While serializing ~S,"
                                           object type field)))
            (let ((result (emit-non-repeated-field
  
negative.code:     (dolist (field (proto-fields msg-desc) size)
        (iincf size (emit-field object field buffer)))))
  
  (defun emit-field (object field buffer)
    (declare (type field-descriptor field))
    (flet ((read-slot (object slot reader)
             ;; Don't do a boundp check, we assume the object is fully populated
             ;; Unpopulated slots should be "nullable" and will contain nil when empty
             (if reader
                 (funcall reader object)
                 (slot-value object slot))))
      "Serialize FIELD in OBJECT to BUFFER"
      (unless
          (if (eq (slot-value field 'message-type) :extends)
              (has-extension object (slot-value field 'internal-field-name))
  