safe-copy-tree. Correct mistakes from earlier patch.

* lisp/emacs-lisp/bytecomp.el (compile-defun): Remove unintended change.

* lisp/subr.el (safe-copy-tree--seen): Correct grammatical error in doc
string.
(safe-copy-tree): Delete hash table at end of function.

* doc/lispref/lists.texi (Building Lists): Add an "@end defun" line.

doc/lispref/lists.texi

@@ -719,6 +719,7 @@ Normally, when @var{tree} is anything other than a cons cell,
 non-@code{nil}, it copies vectors and records too (and operates
 recursively on their elements).  This function handles circular lists
 and vectors, and is thus slower than @code{copy-tree} for typical cases.
+@end defun
 
 @defun flatten-tree tree
 This function returns a ``flattened'' copy of @var{tree}, that is,

lisp/emacs-lisp/bytecomp.el

@@ -2294,19 +2294,12 @@ With argument ARG, insert value in current buffer after the form."
            (symbols-with-pos-enabled t)
 	   (value (eval
 		   (displaying-byte-compile-warnings
-;;;; NEW STOUGH, 2023-03-05
-                    (byte-run-strip-symbol-positions
-;;;; END OF NEW STOUGH
 		    (byte-compile-sexp
                      (let ((form (read-positioning-symbols (current-buffer))))
                        (push form byte-compile-form-stack)
                        (eval-sexp-add-defvars
                         form
-                        start-read-position)))
-;;;; NEW STOUGH, 2023-03-05
-                    )
-;;;; END OF NEW STOUGH
-                                              )
+                        start-read-position))))
                    lexical-binding)))
       (cond (arg
 	     (message "Compiling from buffer... done.")

lisp/subr.el

@@ -848,8 +848,8 @@ argument VECP, this copies vectors as well as conses."
 
 (defvar safe-copy-tree--seen nil
   "A hash table for conses/vectors/records already seen by safe-copy-tree-1.
-It's key is a cons or vector/record seen by the algorithm, and its value is
-the corresponding cons/vector/record in the copy.")
+Its key is a cons or vector/record seen by the algorithm, and its
+value is the corresponding cons/vector/record in the copy.")
 
 (defun safe-copy-tree--1 (tree &optional vecp)
   "Make a copy of TREE, taking circular structure into account.
@@ -896,7 +896,10 @@ If TREE is a cons cell, this recursively copies both its car and its cdr.
 Contrast to `copy-sequence', which copies only along the cdrs.  With second
 argument VECP, this copies vectors and records as well as conses."
   (setq safe-copy-tree--seen (make-hash-table :test #'eq))
-  (safe-copy-tree--1 tree vecp))
+  (unwind-protect
+      (safe-copy-tree--1 tree vecp)
+    (clrhash safe-copy-tree--seen)
+    (setq safe-copy-tree--seen nil)))
 
 
 ;;;; Various list-search functions.