Add a proper type for obarrays

The new opaque type replaces the previous use of vectors for obarrays.
`obarray-make` now returns objects of this type.  Functions that take
obarrays continue to accept vectors for compatibility, now just using
their first slot to store an actual obarray object.

obarray-size and obarray-default-size now obsolete.

* lisp/obarray.el (obarray-default-size, obarray-size):
Declare obsolete.
(obarray-make, obarrayp, obarray-clear): Remove from here.
* src/fns.c (reduce_emacs_uint_to_hash_hash): Remove from here.
* src/lisp.h (struct Lisp_Obarray, OBARRAYP, XOBARRAY, CHECK_OBARRAY)
(make_lisp_obarray, obarray_size, check_obarray)
(obarray_iter_t, make_obarray_iter, obarray_iter_at_end)
(obarray_iter_step, obarray_iter_symbol, DOOBARRAY, knuth_hash): New.
(reduce_emacs_uint_to_hash_hash): Moved here.
* src/lread.c (check_obarray): Renamed and reworked as...
(checked_obarray_slow): ...this.
(intern_sym, Funintern, oblookup, map_obarray)
(Finternal__obarray_buckets): Adapt to new type.
(obarray_index, allocate_obarray, make_obarray, grow_obarray)
(obarray_default_bits, Fobarray_make, Fobarrayp, Fobarray_clear): New.
* etc/emacs_lldb.py (Lisp_Object):
* lisp/emacs-lisp/cl-macs.el (`(,type . ,pred)):
* lisp/emacs-lisp/cl-preloaded.el (cl--typeof-types):
* lisp/emacs-lisp/comp-common.el (comp-known-type-specifiers):
* lisp/emacs-lisp/comp.el (comp-known-predicates):
* src/alloc.c (cleanup_vector, process_mark_stack):
* src/data.c (Ftype_of, syms_of_data):
* src/minibuf.c (Ftry_completion, Fall_completions, Ftest_completion):
* src/pdumper.c (dump_obarray_buckets, dump_obarray, dump_vectorlike):
* src/print.c (print_vectorlike_unreadable):
* test/lisp/abbrev-tests.el (abbrev-make-abbrev-table-test):
* test/lisp/obarray-tests.el (obarrayp-test)
(obarrayp-unchecked-content-test, obarray-make-default-test)
(obarray-make-with-size-test):
Adapt to new type.

lisp/emacs-lisp/cl-macs.el

@@ -3488,6 +3488,7 @@ Of course, we really can't know that for sure, so it's just a heuristic."
                  (natnum	. natnump)
                  (number	. numberp)
                  (null		. null)
+                 (obarray	. obarrayp)
                  (overlay	. overlayp)
                  (process	. processp)
                  (real		. numberp)

lisp/emacs-lisp/cl-preloaded.el

@@ -73,7 +73,7 @@
     (module-function function atom)
     (buffer atom) (char-table array sequence atom)
     (bool-vector array sequence atom)
-    (frame atom) (hash-table atom) (terminal atom)
+    (frame atom) (hash-table atom) (terminal atom) (obarray atom)
     (thread atom) (mutex atom) (condvar atom)
     (font-spec atom) (font-entity atom) (font-object atom)
     (vector array sequence atom)

lisp/emacs-lisp/comp-common.el

@@ -240,7 +240,8 @@ Used to modify the compiler environment."
     (integer-or-marker-p (function (t) boolean))
     (integerp (function (t) boolean))
     (interactive-p (function () boolean))
-    (intern-soft (function ((or string symbol) &optional vector) symbol))
+    (intern-soft (function ((or string symbol) &optional (or obarray vector))
+                           symbol))
     (invocation-directory (function () string))
     (invocation-name (function () string))
     (isnan (function (float) boolean))

lisp/emacs-lisp/comp.el

@@ -214,6 +214,7 @@ Useful to hook into pass checkers.")
     (number-or-marker-p  . number-or-marker)
     (numberp             . number)
     (numberp             . number)
+    (obarrayp            . obarray)
     (overlayp            . overlay)
     (processp            . process)
     (sequencep           . sequence)

lisp/emacs-lisp/shortdoc.el

@@ -747,9 +747,13 @@ A FUNC form can have any number of `:no-eval' (or `:no-value'),
   (intern
    :eval (intern "abc"))
   (intern-soft
+   :eval (intern-soft "list")
    :eval (intern-soft "Phooey!"))
   (make-symbol
    :eval (make-symbol "abc"))
+  (gensym
+   :no-eval (gensym)
+   :eg-result g37)
   "Comparing symbols"
   (eq
    :eval (eq 'abc 'abc)
@@ -760,7 +764,20 @@ A FUNC form can have any number of `:no-eval' (or `:no-value'),
    :eval (equal 'abc 'abc))
   "Name"
   (symbol-name
-   :eval (symbol-name 'abc)))
+   :eval (symbol-name 'abc))
+  "Obarrays"
+  (obarray-make
+   :eval (obarray-make))
+  (obarrayp
+   :eval (obarrayp (obarray-make))
+   :eval (obarrayp nil))
+  (unintern
+   :no-eval (unintern "abc" my-obarray)
+   :eg-result t)
+  (mapatoms
+   :no-eval (mapatoms (lambda (symbol) (print symbol)) my-obarray))
+  (obarray-clear
+   :no-eval (obarray-clear my-obarray)))
 
 (define-short-documentation-group comparison
   "General-purpose"