Merge from origin/emacs-30

9a07d64f5c ; Minor update in ack.texi
b3881ac443 ; Improve type specifier documentation
6a3e2b88d2 ; Improve documentation of "function types"

doc/emacs/ack.texi

@@ -1301,8 +1301,14 @@ Tibor @v{S}imko and Milan Zamazal wrote @file{slovak.el}, support for
 editing text in Slovak language.
 
 @item
+<<<<<<< HEAD
 Jo@~ao T@'avora wrote many improvements for @file{flymake.el}, an
 on-the-fly syntax-checking package.
+=======
+João Távora wrote many improvements for @file{flymake.el}, an on-the-fly
+syntax-checking package.  He also wrote @file{eglot.el}, a language
+server protocol (LSP) client that was added in Emacs 29.
+>>>>>>> 9a07d64f5c734f08baa741d763640943a7b407e7
 
 @item
 Luc Teirlinck wrote @file{help-at-pt.el}, providing local help through

doc/lispref/functions.texi

@@ -2843,24 +2843,27 @@ for the code emitted for the function (@pxref{Native-Compilation
 Variables}).
 
 @cindex function type declaration
+@cindex inferred type of function
 @item (ftype @var{type} &optional @var{function})
-Declare @var{type} to be the type of this function.  This is used for
-documentation by @code{describe-function}.  Also it can be used by the
-native compiler (@pxref{Native Compilation}) for improving code
-generation and for deriving more precisely the type of other functions
-without type declaration.
+Declare @var{type} to be the type of this function.  This type is used
+by @code{describe-function} for documentation, and by the native
+compiler (@pxref{Native Compilation}) for optimizing code generation and
+inferring types.  Incorrect type declarations may cause crashes in
+natively compiled code (see below).  Functions with type declarations
+are shown by @kbd{C-h C-f} as having a @dfn{declared type}, as opposed
+to an @dfn{inferred type} for functions without them.
 
-@var{type} is a @dfn{type specifier} (@pxref{Type Specifiers}) in the
+@var{type} is a @dfn{type specifier} (@pxref{Type Specifiers}) of the
 form @w{@code{(function (@var{arg-1-type} @dots{} @var{arg-n-type})
-RETURN-TYPE)}}.  Argument types can be interleaved with symbols
-@code{&optional} and @code{&rest} to match the function's arguments
+RETURN-TYPE)}}.  Argument types can be interleaved with @code{&optional}
+and @code{&rest} to reflect the function's calling convention
 (@pxref{Argument List}).
 
 @var{function} if present should be the name of function being defined.
 
-Here's an example of using @code{ftype} inside @code{declare} to declare
-a function @code{positive-p} that takes an argument of type @var{number}
-and return a @var{boolean}:
+Here's an example of using @code{ftype} inside @code{declare} to define
+a function @code{positive-p}, which takes an argument of type
+@var{number} and returns a @var{boolean}:
 
 @lisp
 @group
@@ -2871,9 +2874,9 @@ and return a @var{boolean}:
 @end group
 @end lisp
 
-Similarly this declares a function @code{cons-or-number} that: expects a
-first argument being a @var{cons} or a @var{number}, a second optional
-argument of type @var{string} and return one of the symbols
+Similarly, this defines a function @code{cons-or-number} that takes a
+first argument of type @var{cons} or a @var{number}, a second optional
+argument of type @var{string}, and returns one of the symbols
 @code{is-cons} or @code{is-number}:
 
 @lisp
@@ -2891,6 +2894,7 @@ argument of type @var{string} and return one of the symbols
 
 For description of additional types, see @ref{Lisp Data Types}).
 
+<<<<<<< HEAD
 Declaring a function with an incorrect type produces undefined behavior
 and could lead to unexpected results or might even crash Emacs when
 native-compiled code is loaded, if it was compiled with
@@ -2898,6 +2902,14 @@ native-compiled code is loaded, if it was compiled with
 Note also that when redefining (or advising) a type-declared function,
 the replacement should respect the original signature to avoid such
 undefined behavior.
+=======
+Declaring a function with an incorrect type causes undefined behavior.
+If such a function is natively compiled with @code{compilation-safety}
+set to zero (@pxref{compilation-safety}), this may result in incorrect
+execution or even Emacs crashing when the compiled code is loaded.
+Redefining or advising a type-declared function must preserve the
+original signature to avoid these issues.
+>>>>>>> 9a07d64f5c734f08baa741d763640943a7b407e7
 
 @item no-font-lock-keyword
 This is valid for macros only.  Macros with this declaration are

doc/lispref/objects.texi

@@ -1508,12 +1508,14 @@ A type specifier is an expression that denotes a type.  A type
 represents a set of possible values.  Type specifiers can be classified
 into primitive types and compound types.
 
-Type specifiers are in use for several purposes, including: documenting
-function interfaces through declaration (@pxref{Declare Form}),
-specifying structure slot values (@pxref{Structures,,, cl, Common Lisp
-Extensions for GNU Emacs Lisp}), type-checking through @code{cl-the}
-(@pxref{Declarations,,, cl, Common Lisp Extensions for GNU Emacs Lisp}),
-and others.
+Type specifiers are used for several purposes, including: documenting
+function interfaces through declarations (@pxref{Declare Form}),
+specifying structure slot types (@pxref{Structures,,, cl, Common Lisp
+Extensions for GNU Emacs Lisp}), performing type checks with
+@code{cl-the} (@pxref{Declarations,,, cl, Common Lisp Extensions for GNU
+Emacs Lisp}), and aiding the native compiler (@pxref{Native
+Compilation}) in optimizing code generation and inferring function
+signatures.
 
 @table @asis
 @item Primitive type specifiers
@@ -1552,9 +1554,9 @@ types and the return type of a function.  Argument types can be interleaved
 with symbols @code{&optional} and @code{&rest} to match the function's
 arguments (@pxref{Argument List}).
 
-The type specifier represent a function whose first parameter is of type
-@code{symbol}, the second optional parameter is of type @code{float},
-and which returns an @code{integer}:
+The following type specifier represents a function whose first parameter
+is of type @code{symbol}, the second optional parameter is of type
+@code{float}, and which returns an @code{integer}:
 
 @example
  (function (symbol &optional float) integer)