counsel-set-variable fails for variables with non-symbol values

[kaushalmodi]

I have counsel-find-file-ignore-regexp set as below:

    (setq counsel-find-file-ignore-regexp
          (concat
           ;; file names beginning with # or .
           "\\(?:\\`[#.]\\)"
           ;; file names ending with # or ~
           "\\|\\(?:[#~]\\'\\)"))

If I do, M-x counsel-set-variable for that variable, I get

Debugger entered--Lisp error: (wrong-type-argument symbolp "(?:`[#.]\)\|\(?:[#]\'\)")
symbol-name("\(?:\`[#.])|(?:[#]')")
counsel-set-variable()
funcall-interactively(counsel-set-variable)
call-interactively(counsel-set-variable nil nil)
command-execute(counsel-set-variable)

I fixed it by commenting out the symbol-name call for now:

        (let ((res (ivy-read (format "Set (%S): " sym)
                             cands
                             ;; :preselect (symbol-name (symbol-value sym))
                             )))

[kaushalmodi]

This works. I just wish to set the ‹%s› portion to a different face.

(defun counsel-set-variable ()
  "Set a variable, with completion.

When the selected variable is a `defcustom' with the type boolean
or radio, offer completion of all possible values.

Otherwise, offer a variant of `eval-expression', with the initial
input corresponding to the chosen variable."
  (interactive)
  (let ((sym (intern
              (ivy-read "Variable: "
                        (counsel-variable-list)
                        :preselect (thing-at-point 'symbol)
                        :history 'counsel-set-variable-history)))
        sym-type
        cands)
    (if (and (boundp sym)
             (setq sym-type (get sym 'custom-type))
             (cond
              ((and (consp sym-type)
                    (memq (car sym-type) '(choice radio)))
               (setq cands (delq nil (mapcar #'counsel--setq-doconst (cdr sym-type)))))
              ((eq sym-type 'boolean)
               (setq cands '(("nil" . nil) ("t" . t))))
              (t nil)))
        (let ((res (ivy-read (format "Set (%S ‹%s›): " sym (symbol-value sym))
                             cands)))
          (when res
            (setq res
                  (if (assoc res cands)
                      (cdr (assoc res cands))
                    (read res)))
            (eval `(setq ,sym ,res))))
      (counsel-read-setq-expression sym))))

[abo-abo]

Thanks.