Re: Excessive use of `eassert`

[Paul Eggert <eggert@cs.ucla.edu>]

On 1/23/24 03:42, Alan Mackenzie wrote:
> It's not about the debug build, but a normal build, where easserts don't
> play a role.
> 
> The scenario is when symbols_with_pos_enabled is false, and XSYMBOL is
> invalidly given a symbol with position as argument.  Before your
> patches, this would lead to an exception.  After your patches, this no
> longer happens.

I don't see a problem there. XSYMBOL can be called only on symbols, 
regardless of whether symbols-with-pos-enabled is true. When 
symbols-with-pos-enabled is false, XSYMBOL's argument therefore cannot 
be a symbol with position as these are symbols only when 
symbol-with-pos-enabled is true.

It sounds like you're thinking that, even in normal builds (i.e., 
without --enable-debugging), XSYMBOL's implementation should have some 
sort of debugging code that is not needed for correct behavior and that 
can slow down execution. I don't see why that needs to happen. In normal 
builds, XSYMBOL does not check that its argument is a symbol, and it has 
undefined behavior if buggy C code gives it a non-symbol. As I 
understand it, a symbol with position SP is not a symbol if 
symbols-with-pos-enabled is false. This means it's OK if XSYMBOL (SP) 
has undefined behavior when symbols-with-pos-enabled is false in a 
normal build.

Here's an example to try to make my meaning clearer. Suppose we define a 
buggy Lisp function in C as follows:

   DEFUN ("buggy-symbol-name", Fbuggy_symbol_name,
          Sbuggy_symbol_name, 1, 1, 0,
          doc: /* Return SYMBOL's name, a string.  */)
     (Lisp_Object symbol)
   {
     return XSYMBOL (symbol)->u.s.name;
   }

This C function has a bug: it doesn't check that its argument is a 
symbol before calling XSYMBOL. And because of the bug, this:

   (buggy-symbol-name (position-symbol nil 1))

has undefined behavior when Emacs is built without --enable-debugging. 
In the current implementation this undefined behavior causes 
buggy-symbol-name to return "nil", whereas it would be nicer in some 
sense if Emacs crashed and dumped core due to the bug in the C code.

However, symbols with positions aren't necessarily being treated 
differently from other Lisp objects here. For example, this:

   (buggy-symbol-name "abc")

also has undefined behavior, and on my platform this latter expression 
returns nil, also without dumping core. Although it would also be nicer 
in some sense if Emacs crashed and dumped core due to the bug in the C 
code, Emacs doesn't do that, for valid performance reasons.

For Emacs to reliably crash right away in situations like these, it 
needs to be built with --enable-debugging.