Get rid of funvec.

* lisp/emacs-lisp/bytecomp.el (byte-compile-lapcode): Handle new form of
`byte-constant'.
(byte-compile-close-variables, displaying-byte-compile-warnings):
Add edebug spec.
(byte-compile-toplevel-file-form): New fun, split out of
byte-compile-file-form.
(byte-compile-from-buffer): Use it to avoid applying cconv
multiple times.
(byte-compile): Only strip `function' if it's present.
(byte-compile-lambda): Add `reserved-csts' argument.
Use new lexenv arg of byte-compile-top-level.
(byte-compile-reserved-constants): New var.
(byte-compile-constants-vector): Obey it.
(byte-compile-constants-vector): Handle new `byte-constant' form.
(byte-compile-top-level): Add args `lexenv' and `reserved-csts'.
(byte-compile-form): Don't check callargs here.
(byte-compile-normal-call): Do it here instead.
(byte-compile-push-unknown-constant)
(byte-compile-resolve-unknown-constant): Remove, unused.
(byte-compile-make-closure): Use `make-byte-code' rather than `curry',
putting the environment into the "constant" pool.
(byte-compile-get-closed-var): Use special byte-constant.
* lisp/emacs-lisp/byte-opt.el (byte-optimize-form-code-walker): Handle new
intermediate special form `internal-make-vector'.
(byte-optimize-lapcode): Handle new form of `byte-constant'.
* lisp/help-fns.el (describe-function-1): Don't handle funvecs.
* lisp/emacs-lisp/macroexp.el (macroexpand-all-1): Only convert quote to
function if the content is a lambda expression, not if it's a closure.
* emacs-lisp/eieio-come.el: Remove.
* lisp/emacs-lisp/eieio.el: Don't require eieio-comp.
(defmethod): Do a bit more work to find the body and wrap it into
a function before passing it to eieio-defmethod.
(eieio-defmethod): New arg `code' for it.
* lisp/emacs-lisp/debug.el (debugger-setup-buffer): Don't hide things in
debugger backtrace.
* lisp/emacs-lisp/cl-extra.el (cl-macroexpand-all): Use backquotes, and be
more careful when quoting a function value.
* lisp/emacs-lisp/cconv.el (cconv-freevars): Accept defvar/defconst.
(cconv-closure-convert-rec): Catch stray `internal-make-closure'.
* lisp/Makefile.in (COMPILE_FIRST): Compile pcase and cconv early.

* src/eval.c (Qcurry): Remove.
(funcall_funvec): Remove.
(funcall_lambda): Move new byte-code handling to reduce impact.
Treat all args as lexical in the case of lexbind.
(Fcurry): Remove.
* src/data.c (Qfunction_vector): Remove.
(Ffunvecp): Remove.
* src/lread.c (read1): Revert to calling make_byte_code here.
(read_vector): Don't call make_byte_code any more.
* src/lisp.h (enum pvec_type): Rename back to PVEC_COMPILED.
(XSETCOMPILED): Rename back from XSETFUNVEC.
(FUNVEC_SIZE): Remove.
(FUNVEC_COMPILED_TAG_P, FUNVEC_COMPILED_P): Remove.
(COMPILEDP): Rename back from FUNVECP.
* src/fns.c (Felt): Remove unexplained FUNVEC check.
* src/doc.c (Fdocumentation): Don't handle funvec.
* src/alloc.c (make_funvec, Ffunvec): Remove.
* doc/lispref/vol2.texi (Top):
* doc/lispref/vol1.texi (Top):
* doc/lispref/objects.texi (Programming Types, Funvec Type, Type Predicates):
* doc/lispref/functions.texi (Functions, What Is a Function, FunctionCurrying):
* doc/lispref/elisp.texi (Top): Remove mentions of funvec and curry.

1 files changed, 7 insertions, 64 deletions

diff --git a/src/alloc.c b/src/alloc.c
index 81a17b5c13b..0b7db7ec627 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -2924,37 +2924,6 @@ See also the function `vector'.  */)
 }
 
 
-/* Return a new `function vector' containing KIND as the first element,
-   followed by NUM_NIL_SLOTS nil elements, and further elements copied from
-   the vector PARAMS of length NUM_PARAMS (so the total length of the
-   resulting vector is 1 + NUM_NIL_SLOTS + NUM_PARAMS).
-
-   If NUM_PARAMS is zero, then PARAMS may be NULL.
-
-   A `function vector', a.k.a. `funvec', is a funcallable vector in Emacs Lisp.
-   See the function `funvec' for more detail.  */
-
-Lisp_Object
-make_funvec (Lisp_Object kind, int num_nil_slots, int num_params,
-             Lisp_Object *params)
-{
-  int param_index;
-  Lisp_Object funvec;
-
-  funvec = Fmake_vector (make_number (1 + num_nil_slots + num_params), Qnil);
-
-  ASET (funvec, 0, kind);
-
-  for (param_index = 0; param_index < num_params; param_index++)
-    ASET (funvec, 1 + num_nil_slots + param_index, params[param_index]);
-
-  XSETPVECTYPE (XVECTOR (funvec), PVEC_FUNVEC);
-  XSETFUNVEC (funvec, XVECTOR (funvec));
-
-  return funvec;
-}
-
-
 DEFUN ("vector", Fvector, Svector, 0, MANY, 0,
        doc: /* Return a newly created vector with specified arguments as elements.
 Any number of arguments, even zero arguments, are allowed.
@@ -2974,27 +2943,6 @@ usage: (vector &rest OBJECTS)  */)
 }
 
 
-DEFUN ("funvec", Ffunvec, Sfunvec, 1, MANY, 0,
-       doc: /* Return a newly created `function vector' of type KIND.
-A `function vector', a.k.a. `funvec', is a funcallable vector in Emacs Lisp.
-KIND indicates the kind of funvec, and determines its behavior when called.
-The meaning of the remaining arguments depends on KIND.  Currently
-implemented values of KIND, and their meaning, are:
-
-   A list  -- A byte-compiled function.  See `make-byte-code' for the usual
-              way to create byte-compiled functions.
-
-   `curry' -- A curried function.  Remaining arguments are a function to
-              call, and arguments to prepend to user arguments at the
-              time of the call; see the `curry' function.
-
-usage: (funvec KIND &rest PARAMS)  */)
-     (int nargs, Lisp_Object *args)
-{
-  return make_funvec (args[0], 0, nargs - 1, args + 1);
-}
-
-
 DEFUN ("make-byte-code", Fmake_byte_code, Smake_byte_code, 4, MANY, 0,
        doc: /* Create a byte-code object with specified arguments as elements.
 The arguments should be the arglist, bytecode-string, constant vector,
@@ -3008,10 +2956,6 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
   register int index;
   register struct Lisp_Vector *p;
 
-  /* Make sure the arg-list is really a list, as that's what's used to
-     distinguish a byte-compiled object from other funvecs.  */
-  CHECK_LIST (args[0]);
-
   XSETFASTINT (len, nargs);
   if (!NILP (Vpurify_flag))
     val = make_pure_vector ((EMACS_INT) nargs);
@@ -3033,8 +2977,8 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
         args[index] = Fpurecopy (args[index]);
       p->contents[index] = args[index];
     }
-  XSETPVECTYPE (p, PVEC_FUNVEC);
-  XSETFUNVEC (val, p);
+  XSETPVECTYPE (p, PVEC_COMPILED);
+  XSETCOMPILED (val, p);
   return val;
 }
 
@@ -4817,7 +4761,7 @@ Does not copy symbols.  Copies strings without text properties.  */)
     obj = make_pure_string (SSDATA (obj), SCHARS (obj),
                             SBYTES (obj),
                             STRING_MULTIBYTE (obj));
-  else if (FUNVECP (obj) || VECTORP (obj))
+  else if (COMPILEDP (obj) || VECTORP (obj))
     {
       register struct Lisp_Vector *vec;
       register EMACS_INT i;
@@ -4829,10 +4773,10 @@ Does not copy symbols.  Copies strings without text properties.  */)
       vec = XVECTOR (make_pure_vector (size));
       for (i = 0; i < size; i++)
         vec->contents[i] = Fpurecopy (XVECTOR (obj)->contents[i]);
-      if (FUNVECP (obj))
+      if (COMPILEDP (obj))
         {
-          XSETPVECTYPE (vec, PVEC_FUNVEC);
-          XSETFUNVEC (obj, vec);
+          XSETPVECTYPE (vec, PVEC_COMPILED);
+          XSETCOMPILED (obj, vec);
         }
       else
         XSETVECTOR (obj, vec);
@@ -5418,7 +5362,7 @@ mark_object (Lisp_Object arg)
         }
       else if (SUBRP (obj))
         break;
-      else if (FUNVECP (obj) && FUNVEC_COMPILED_P (obj))
+      else if (COMPILEDP (obj))
         /* We could treat this just like a vector, but it is better to
            save the COMPILED_CONSTANTS element for last and avoid
            recursion there.  */
@@ -6320,7 +6264,6 @@ The time is in seconds as a floating point value.  */);
   defsubr (&Scons);
   defsubr (&Slist);
   defsubr (&Svector);
-  defsubr (&Sfunvec);
   defsubr (&Smake_byte_code);
   defsubr (&Smake_list);
   defsubr (&Smake_vector);