backward-kill-word kills too much, how to make it more intelligent?

Question

I'm looking for a way to reduce what Emacs kills when I use backward-kill-word.

protected virtual void OnPropertyChanged(PropertyChangedEventArgs e)
{
    if (PropertyChanged != null)
        PropertyChanged(this, e);
}

If I'm editing the above code in Emacs and I place my cursor on the very last character (the }) and I call backward-kill-word, the entirety of e); is killed, since Emacs only considers the e to be a word.

Another example is if you place your cursor on the 'P' of PropertyChanged(this, e) and call backward-kill-word, the entirety of null) before it is killed. The closed parenthesis is simply considered to not be a word.

My question is how I can eliminate this behavior. I want characters like ), ', }, etc. to be treated as words by backward-kill-word. This means that backward-kill-word kills these characters and the cursor replaces them, just how backward-kill-word typically behaves for one-character-long words like e. One possible solution I've thought of is to somehow edit what Emacs considers to be words and simply add the characters I want to the list. Regardless, thanks for the help!

Answer 1

Here's a quick attempt at a custom function that may do what you want:

(defun backward-kill-char-or-word ()
  "Delete the character or word before point."
  (interactive)
  (if (looking-back "\\w" 1)
      (backward-kill-word 1)
    (backward-delete-char 1)))

This looks back one character to decide what to do. If it sees a word constituent character it kills the word, otherwise it just deletes one character. There may be other cases you needed to handle, this is "lightly tested".

You can revise this to handle whitespace in different ways. If you want to delete spaces along with the next word (which is what backward-kill-word does), try this:

(defun backward-kill-char-or-word ()
  (interactive)
  (if (looking-back (rx (char word blank)) 1)
      (backward-kill-word 1)
    (backward-delete-char 1)))

If you want to delete a sequence of whitespace as a unit but stop at a word, try this:

(defun backward-kill-char-or-word ()
  (interactive)
  (cond 
   ((looking-back (rx (char word)) 1)
    (backward-kill-word 1))
   ((looking-back (rx (char blank)) 1)
    (delete-horizontal-space t))
   (t
    (backward-delete-char 1))))

Answer 2

Emacs uses syntax tables to decide what is and is not a word. Each major mode will have its own syntax table. Commands that move over or delete words will use the values in this table to determine how far to go.

The key syntax class in this case is the 'word constituent'. Deleting a word in Emacs works by deleting whole groups of adjacent word constituents.

To add characters to the 'word constituent' class you can use modify-syntax-entry. For example, to add the character ), you'd use the following:

(modify-syntax-entry ?) "w") 

By default, this will modify the current syntax table. You'll need to do a bit more to target the syntax table for a particular mode. For example, I have the following in my .init.el:

(eval-after-load "bibtex"
     (modify-syntax-entry ?% "_" bibtex-mode-syntax-table))

This will modify the syntax table for bibtex-mode after it's loaded, changing the % character to a 'symbol constituent'. See the linked manual page for more details on the different syntax classes and how to set them.

Caution

As @politza points out, changing the syntax table may have unintended consequences. Syntax classes are a pretty fundamental structure in Emacs, and many different functions depend on them, not just movement and deletion commands. So you might find surprising bugs arise as a consequence of such changes.