anchor.diff:          (if (null field)
               (skip-json-value stream)
               (let (val error-p)
  -              (if (eq (proto-label field) :repeated)
  +              (if (not (eq (proto-label field) :repeated))
  +                  (multiple-value-setq (val error-p)
  +                    (parse-value-from-json type :stream stream))
                     (case (peek-char nil stream nil)
                       ;; Repeated field is in list format
                       ((#\[)
  
positive.code:                     ((#\n)
                       (let ((tok (parse-token stream)))
                         (unless (string= tok "null")
                           (setf error-p t)))))
                    (multiple-value-setq (val error-p)
                      (parse-value-from-json type :stream stream)))
                (cond
                  (error-p
                   (undefined-field-type "While parsing ~S from JSON format,"
  
negative.code:             (if indent
                  (format stream "~&~V,0T\"~A\": " (+ indent 2) name)
                  (format stream "\"~A\":" name))
              (if (not (eq (proto-label field) :repeated))
                  (print-field-to-json value type (and indent (+ indent 2))
                                       stream camel-case-p numeric-enums-p)
                  (let (repeated-printed)
                    (format stream "[")
                    (doseq (v value)
                      (if repeated-printed
                          (format stream ",")
                          (setf repeated-printed t))
                      (when indent (format stream "~&~V,0T" (+ indent 4)))
                      (print-field-to-json v type (and indent (+ indent 4))
                                           stream camel-case-p numeric-enums-p))
                    (if indent
                        (format stream "~&~V,0T]" (+ indent 2))
                        (format stream "]")))))))
        (dolist (oneof (proto-oneofs message))
          (let* ((oneof-data (slot-value object (oneof-descriptor-internal-name oneof)))
                 (set-field (oneof-set-field oneof-data)))
            (when set-field
              (let* ((field-desc (aref (oneof-descriptor-fields oneof) set-field))
                     (type (proto-class field-desc))
                     (value (oneof-value oneof-data))
                     (name (if camel-case-p
                               (proto-json-name field-desc)
                               (proto-name field-desc))))
                (if field-printed
                    (format stream ",")
                    (setf field-printed t))
                (if indent
                    (format stream "~&~V,0T\"~A\": " (+ indent 2) name)
                    (format stream "\"~A\":" name))
                (print-field-to-json value type (and indent (+ indent 2))
                                     stream camel-case-p numeric-enums-p))))))
      (if indent
          (format stream "~&~V,0T}" indent)
          (format stream "}"))))
  
  (defun print-field-to-json (value type indent stream camel-case-p numeric-enums-p)
    "Print a field to JSON format.
  