bug#63410: 30.0.50; [FR] Optionally allow defcustom to check type for standard value

[Ruijie Yu via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org>]

[-- Attachment #1: Type: text/plain, Size: 776 bytes --]


Ruijie Yu via "Bug reports for GNU Emacs, the Swiss army knife of text editors" <bug-gnu-emacs@gnu.org> writes:

> In that case, I had my semi-parallel second proposal: provide a command
> that checks for a group of variables and see if types of all variables
> within the group (or its subgroups) are correct.

Regarding the second proposal: I have quickly hacked together a
functional example of type checking, see the attachment.  If we think
this should be integrated into Emacs, I can make some minor edits and
propose a patch.  In that case, I would probably put the functions
somewhere in cus-edit.el or custom.el.

Note that at the moment it depends on the internal function
`custom--standard-value', which is a one-line function accessing a
property of the symbol.


[-- Attachment #2: cfg-check-defcustom.el --]
[-- Type: text/plain, Size: 1827 bytes --]

;;; cfg-check-defcustom.el --- Ensure type-strictness of defcustom

;;; Commentary:

;;; Code:
(autoload 'customize-read-group "cus-edit")
(autoload 'custom-variable-prompt "cus-edit")

(defun ccd (variable)
  "Check the standard value of VARIABLE is of the correct type."
  (interactive (custom-variable-prompt))
  (custom-load-symbol variable)
  (when-let ((type (get variable 'custom-type)))
    (let ((value (custom--standard-value variable)))
      (unless (widget-apply (widget-convert type) :match value)
        (warn "Type mismatch on `%s': value `%S'; type %s"
              variable value type)))))

(defun ccd--vars-in-group (group &optional recursive)
  "Return a list of all variable symbols contained in GROUP.
When RECURSIVE is non-nil, the list contains variables in
subgroups recursively."
  (when-let (((symbolp group))
             (gp (get group 'custom-group)))
    (let* ((filter
            (lambda (s)
              (mapcar
               #'car (seq-filter (lambda (c) (eq s (nth 1 c))) gp))))
           (child (funcall filter 'custom-variable))
           (subgroup (and recursive
                          (funcall filter 'custom-group))))
      (nconc child (mapcan #'ccd--vars-in-group-r subgroup)))))

(defun ccd--vars-in-group-r (group)
  "Shorthand for \\(cfg-check-defcustom--vars-in-group GROUP t)."
  (ccd--vars-in-group group t))

(defun ccd-group (group &optional recursive)
  "Check all variables within GROUP.
When RECURSIVE is non-nil, check the group recursively.  See also
`cfg-check-defcustom'."
  (interactive (list (customize-read-group) current-prefix-arg))
  (mapc #'ccd (ccd--vars-in-group (intern group) recursive)))

(provide 'cfg-check-defcustom)
;;; cfg-check-defcustom.el ends here.

;; Local Variables:
;; read-symbol-shorthands: (("ccd" . "cfg-check-defcustom"))
;; End:

[-- Attachment #3: Type: text/plain, Size: 303 bytes --]


Also, note that I added the symbol into the warning text because the
goal of this command is to mass-check an entire group, whereas `setopt'
did not mention the variable symbol name.  Not sure if `setopt' should
show the symbol in trouble, but I understand if we don't want to do
that.

-- 
Best,


RY