[elpa] externals/compat 3a6990e954 09/13: Rename named-let name in tests to avoid byte compiler warnings

[ELPA Syncer]

branch: externals/compat
commit 3a6990e954cd9b08f78067eee01af1bb998170c0
Author: Philip Kaludercic <philipk@posteo.net>
Commit: Philip Kaludercic <philipk@posteo.net>

    Rename named-let name in tests to avoid byte compiler warnings
    
    The name "loop" appears to confuse the byte-compiler, as it might be
    mistakenly taken to be the prefix-less "cl-loop" macro.
---
 compat-tests.el | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/compat-tests.el b/compat-tests.el
index 8d30f24d13..6e45b00c7e 100644
--- a/compat-tests.el
+++ b/compat-tests.el
@@ -1066,43 +1066,43 @@ being compared against."
              100000))
   (should (= (compat--named-let l ((i 0) (x 1)) (if (= i 8) x (l (1+ i) (* x 
2))))
              (expt 2 8)))
-  (should (eq (compat--named-let loop ((x 1))
+  (should (eq (compat--named-let lop ((x 1))
                 (if (> x 0)
                     (condition-case nil
-                        (loop (1- x))
+                        (lop (1- x))
                       (arith-error 'ok))
                   (/ 1 x)))
               'ok))
-  (should (eq (compat--named-let loop ((n 10000))
+  (should (eq (compat--named-let lop ((n 10000))
                 (if (> n 0)
                     (condition-case nil
                         (/ n 0)
-                      (arith-error (loop (1- n))))
+                      (arith-error (lop (1- n))))
                   'ok))
               'ok))
-  (should (eq (compat--named-let loop ((x nil))
+  (should (eq (compat--named-let lop ((x nil))
                 (cond (x)
                       (t 'ok)))
               'ok))
-  (should (eq (compat--named-let loop ((x 100000))
+  (should (eq (compat--named-let lop ((x 100000))
                 (cond ((= x 0) 'ok)
-                      ((loop (1- x)))))
+                      ((lop (1- x)))))
               'ok))
-  (should (eq (compat--named-let loop ((x 100000))
+  (should (eq (compat--named-let lop ((x 100000))
                 (cond
                  ((= x -1) nil)
                  ((= x 0) 'ok)
-                 ((loop -1))
-                 ((loop (1- x)))))
+                 ((lop -1))
+                 ((lop (1- x)))))
               'ok))
-  (should (eq (compat--named-let loop ((x 10000))
+  (should (eq (compat--named-let lop ((x 10000))
                 (cond ((= x 0) 'ok)
-                      ((and t (loop (1- x))))))
+                      ((and t (lop (1- x))))))
               'ok))
   (should (eq (eval
-               (let ((branch '((loop (and (setq b (not b)) (1+ i))))))
+               (let ((branch '((lop (and (setq b (not b)) (1+ i))))))
                  `(let ((b t))
-                    (compat--named-let loop ((i 0))
+                    (compat--named-let lop ((i 0))
                       (cond ((null i) nil)
                             ((= i 10000) 'ok)
                             ,branch