Revert "Replace XSETSYMBOL with make_lisp_symbol"

This reverts commit de6b1e1efb1a36c69e7a6e09297e1de5b1477121.

While it did simplify code, there aren't much in the way of technical
benefits the change at this time, and there were protest against the
unwarranted style change.

5 files changed, 31 insertions, 21 deletions

diff --git a/src/alloc.c b/src/alloc.c
index 16257469aa6..2ffd2415447 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3960,7 +3960,7 @@ Its value is void, and its function definition and property list are nil.  */)
   if (symbol_free_list)
     {
       ASAN_UNPOISON_SYMBOL (symbol_free_list);
-      val = make_lisp_symbol (symbol_free_list);
+      XSETSYMBOL (val, symbol_free_list);
       symbol_free_list = symbol_free_list->u.s.next;
     }
   else
@@ -3976,7 +3976,7 @@ Its value is void, and its function definition and property list are nil.  */)
         }
 
       ASAN_UNPOISON_SYMBOL (&symbol_block->symbols[symbol_block_index]);
-      val = make_lisp_symbol (&symbol_block->symbols[symbol_block_index]);
+      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
       symbol_block_index++;
     }
 
@@ -7398,8 +7398,12 @@ process_mark_stack (ptrdiff_t base_sp)
                 mark_stack_push_value (SYMBOL_VAL (ptr));
                 break;
               case SYMBOL_VARALIAS:
-                mark_stack_push_value (make_lisp_symbol (SYMBOL_ALIAS (ptr)));
-                break;
+                {
+                  Lisp_Object tem;
+                  XSETSYMBOL (tem, SYMBOL_ALIAS (ptr));
+                  mark_stack_push_value (tem);
+                  break;
+                }
               case SYMBOL_LOCALIZED:
                 {
                   struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (ptr);
diff --git a/src/buffer.c b/src/buffer.c
index 9f55a8813fa..43a9249528c 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1340,7 +1340,7 @@ buffer_local_value (Lisp_Object variable, Lisp_Object buffer)
     case SYMBOL_LOCALIZED:
       { /* Look in local_var_alist.  */
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
-        variable = make_lisp_symbol (sym); /* Update In case of aliasing.  */
+        XSETSYMBOL (variable, sym); /* Update In case of aliasing.  */
         result = assq_no_quit (variable, BVAR (buf, local_var_alist));
         if (!NILP (result))
           {
@@ -4985,7 +4985,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
   sym->u.s.declared_special = true;
   sym->u.s.redirect = SYMBOL_FORWARDED;
   SET_SYMBOL_FWD (sym, bo_fwd);
-  PER_BUFFER_SYMBOL (offset) = make_lisp_symbol (sym);
+  XSETSYMBOL (PER_BUFFER_SYMBOL (offset), sym);
 
   if (PER_BUFFER_IDX (offset) == 0)
     /* Did a DEFVAR_PER_BUFFER without initializing the corresponding
diff --git a/src/data.c b/src/data.c
index c87b5317618..df08eaf8102 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1256,7 +1256,7 @@ If OBJECT is not a symbol, just return it.  */)
       struct Lisp_Symbol *sym = XSYMBOL (object);
       while (sym->u.s.redirect == SYMBOL_VARALIAS)
         sym = SYMBOL_ALIAS (sym);
-      object = make_lisp_symbol (sym);
+      XSETSYMBOL (object, sym);
     }
   return object;
 }
@@ -1506,9 +1506,12 @@ swap_in_symval_forwarding (struct Lisp_Symbol *symbol, struct Lisp_Buffer_Local_
       if (blv->fwd.fwdptr)
         set_blv_value (blv, do_symval_forwarding (blv->fwd));
       /* Choose the new binding.  */
-      tem1 = assq_no_quit (make_lisp_symbol (symbol),
-                           BVAR (current_buffer, local_var_alist));
-      set_blv_where (blv, Fcurrent_buffer ());
+      {
+        Lisp_Object var;
+        XSETSYMBOL (var, symbol);
+        tem1 = assq_no_quit (var, BVAR (current_buffer, local_var_alist));
+        set_blv_where (blv, Fcurrent_buffer ());
+      }
       if (!(blv->found = !NILP (tem1)))
         tem1 = blv->defcell;
 
@@ -1652,8 +1655,7 @@ set_internal (Lisp_Object symbol, Lisp_Object newval, Lisp_Object where,
               set_blv_value (blv, do_symval_forwarding (blv->fwd));
 
             /* Find the new binding.  */
-            /* May have changed via aliasing.  */
-            symbol = make_lisp_symbol (sym);
+            XSETSYMBOL (symbol, sym); /* May have changed via aliasing.  */
             Lisp_Object tem1
               = assq_no_quit (symbol,
                               BVAR (XBUFFER (where), local_var_alist));
@@ -2057,10 +2059,13 @@ make_blv (struct Lisp_Symbol *sym, bool forwarded,
           union Lisp_Val_Fwd valcontents)
 {
   struct Lisp_Buffer_Local_Value *blv = xmalloc (sizeof *blv);
-  Lisp_Object tem = Fcons (make_lisp_symbol (sym),
-                           forwarded
-                           ? do_symval_forwarding (valcontents.fwd)
-                           : valcontents.value);
+  Lisp_Object symbol;
+  Lisp_Object tem;
+
+ XSETSYMBOL (symbol, sym);
+ tem = Fcons (symbol, (forwarded
+                       ? do_symval_forwarding (valcontents.fwd)
+                       : valcontents.value));
 
   /* Buffer_Local_Values cannot have as realval a buffer-local
      or keyboard-local forwarding.  */
@@ -2216,7 +2221,7 @@ Instead, use `add-hook' and specify t for the LOCAL argument.  */)
     }
 
   /* Make sure this buffer has its own value of symbol.  */
-  variable = make_lisp_symbol (sym);    /* Update in case of aliasing.  */
+  XSETSYMBOL (variable, sym);   /* Update in case of aliasing.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (NILP (tem))
     {
@@ -2296,7 +2301,7 @@ From now on the default value will apply in this buffer.  Return VARIABLE.  */)
     notify_variable_watchers (variable, Qnil, Qmakunbound, Fcurrent_buffer ());
 
   /* Get rid of this buffer's alist element, if any.  */
-  variable = make_lisp_symbol (sym);    /* Propagate variable indirection.  */
+  XSETSYMBOL (variable, sym);   /* Propagate variable indirection.  */
   tem = assq_no_quit (variable, BVAR (current_buffer, local_var_alist));
   if (!NILP (tem))
     bset_local_var_alist
@@ -2341,7 +2346,7 @@ Also see `buffer-local-boundp'.*/)
         Lisp_Object tmp;
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
         XSETBUFFER (tmp, buf);
-        variable = make_lisp_symbol (sym); /* Update in case of aliasing.  */
+        XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
 
         if (EQ (blv->where, tmp)) /* The binding is already loaded.  */
           return blv_found (blv) ? Qt : Qnil;
@@ -2391,7 +2396,7 @@ value in BUFFER, or if VARIABLE is automatically buffer-local (see
         struct Lisp_Buffer_Local_Value *blv = SYMBOL_BLV (sym);
         if (blv->local_if_set)
           return Qt;
-        variable = make_lisp_symbol (sym); /* Update in case of aliasing.  */
+        XSETSYMBOL (variable, sym); /* Update in case of aliasing.  */
         return Flocal_variable_p (variable, buffer);
       }
     case SYMBOL_FORWARDED:
diff --git a/src/eval.c b/src/eval.c
index 9d3b98eb359..95eb21909d2 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3475,7 +3475,7 @@ specbind (Lisp_Object symbol, Lisp_Object value)
   switch (sym->u.s.redirect)
     {
     case SYMBOL_VARALIAS:
-      sym = SYMBOL_ALIAS (sym); symbol = make_lisp_symbol (sym); goto start;
+      sym = SYMBOL_ALIAS (sym); XSETSYMBOL (symbol, sym); goto start;
     case SYMBOL_PLAINVAL:
       /* The most common case is that of a non-constant symbol with a
          trivial value.  Make that as fast as we can.  */
diff --git a/src/lisp.h b/src/lisp.h
index 4fc44745211..f353e4956eb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1380,6 +1380,7 @@ make_lisp_ptr (void *ptr, enum Lisp_Type type)
 #define XSETCONS(a, b) ((a) = make_lisp_ptr (b, Lisp_Cons))
 #define XSETVECTOR(a, b) ((a) = make_lisp_ptr (b, Lisp_Vectorlike))
 #define XSETSTRING(a, b) ((a) = make_lisp_ptr (b, Lisp_String))
+#define XSETSYMBOL(a, b) ((a) = make_lisp_symbol (b))
 #define XSETFLOAT(a, b) ((a) = make_lisp_ptr (b, Lisp_Float))
 
 /* Return a Lisp_Object value that does not correspond to any object.