Lazily convert numeric strings to Lisp numbers in Eshell

This should reduce the number of issues with Eshell converting strings
to numbers too aggressively and losing information (e.g. "001" -> 1)
while still allowing almost all of the beneficial uses, like summing a
list of numeric strings with '+'.

* lisp/eshell/esh-util.el (eshell--do-mark-numeric-string): New
function.
(eshell-convert-to-number): Make obsolete in favor of...
(eshell-mark-numeric-string): ... this.  Update callers.

* lisp/eshell/esh-arg.el (eshell--numberlike-p): New function...
(eshell-concat-1): ... use it.

* test/lisp/eshell/esh-util-tests.el:  Reimplement type conversion tests
to use 'eshell-convertible-to-number-p' instead.

* test/lisp/eshell/esh-var-tests.el
(esh-var-test/interp-var-splice-concat, esh-var-test/interp-concat-cmd)
(esh-var-test/interp-convert-var-split-indices)
(esh-var-test/interp-convert-quoted-var-split-indices)
(esh-var-test/interp-convert-cmd-multiline)
(esh-var-test/interp-convert-cmd-split-indices): Adjust tests to check
the new behavior.

* doc/misc/eshell.texi (Type Conversion): New section.
(Expansion): Clarify concatenation behavior.

2 files changed, 83 insertions, 60 deletions

diff --git a/test/lisp/eshell/esh-util-tests.el b/test/lisp/eshell/esh-util-tests.el
index 031de558d1f..4a0874bff39 100644
--- a/test/lisp/eshell/esh-util-tests.el
+++ b/test/lisp/eshell/esh-util-tests.el
@@ -66,70 +66,70 @@
   "Test that `eshell-stringify' correctly stringifies complex objects."
   (should (equal (eshell-stringify (list 'quote 'hello)) "'hello")))
 
-(ert-deftest esh-util-test/eshell-convert-to-number/integer ()
-  "Test that `eshell-convert-to-number' correctly converts integers."
-  (should (equal (eshell-convert-to-number "123") 123))
-  (should (equal (eshell-convert-to-number "-123") -123))
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/integer ()
+  "Test that `eshell-convertible-to-number-p' matches integers."
+  (should (eshell-convertible-to-number-p "123"))
+  (should (eshell-convertible-to-number-p "-123"))
   ;; These are technially integers, since Emacs Lisp requires at least
   ;; one digit after the "." to be a float:
-  (should (equal (eshell-convert-to-number "123.") 123))
-  (should (equal (eshell-convert-to-number "-123.") -123)))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/floating-point ()
-  "Test that `eshell-convert-to-number' correctly converts floats."
-  (should (equal (eshell-convert-to-number "1.23") 1.23))
-  (should (equal (eshell-convert-to-number "-1.23") -1.23))
-  (should (equal (eshell-convert-to-number ".1") 0.1))
-  (should (equal (eshell-convert-to-number "-.1") -0.1)))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/floating-point-exponent ()
-  "Test that `eshell-convert-to-number' correctly converts exponent notation."
+  (should (eshell-convertible-to-number-p "123."))
+  (should (eshell-convertible-to-number-p "-123.")))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/float ()
+  "Test that `eshell-convertible-to-number-p' matches floats."
+  (should (eshell-convertible-to-number-p "1.23"))
+  (should (eshell-convertible-to-number-p "-1.23"))
+  (should (eshell-convertible-to-number-p ".1"))
+  (should (eshell-convertible-to-number-p "-.1")))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/float-exponent ()
+  "Test that `eshell-convertible-to-number-p' matches exponent notation."
   ;; Positive exponent:
   (dolist (exp '("e2" "e+2" "E2" "E+2"))
-    (should (equal (eshell-convert-to-number (concat "123" exp)) 12300.0))
-    (should (equal (eshell-convert-to-number (concat "-123" exp)) -12300.0))
-    (should (equal (eshell-convert-to-number (concat "1.23" exp)) 123.0))
-    (should (equal (eshell-convert-to-number (concat "-1.23" exp)) -123.0))
-    (should (equal (eshell-convert-to-number (concat "1." exp)) 100.0))
-    (should (equal (eshell-convert-to-number (concat "-1." exp)) -100.0))
-    (should (equal (eshell-convert-to-number (concat ".1" exp)) 10.0))
-    (should (equal (eshell-convert-to-number (concat "-.1" exp)) -10.0)))
+    (should (eshell-convertible-to-number-p (concat "123" exp)))
+    (should (eshell-convertible-to-number-p (concat "-123" exp)))
+    (should (eshell-convertible-to-number-p (concat "1.23" exp)))
+    (should (eshell-convertible-to-number-p (concat "-1.23" exp)))
+    (should (eshell-convertible-to-number-p (concat "1." exp)))
+    (should (eshell-convertible-to-number-p (concat "-1." exp)))
+    (should (eshell-convertible-to-number-p (concat ".1" exp)))
+    (should (eshell-convertible-to-number-p (concat "-.1" exp))))
   ;; Negative exponent:
   (dolist (exp '("e-2" "E-2"))
-    (should (equal (eshell-convert-to-number (concat "123" exp)) 1.23))
-    (should (equal (eshell-convert-to-number (concat "-123" exp)) -1.23))
-    (should (equal (eshell-convert-to-number (concat "1.23" exp)) 0.0123))
-    (should (equal (eshell-convert-to-number (concat "-1.23" exp)) -0.0123))
-    (should (equal (eshell-convert-to-number (concat "1." exp)) 0.01))
-    (should (equal (eshell-convert-to-number (concat "-1." exp)) -0.01))
-    (should (equal (eshell-convert-to-number (concat ".1" exp)) 0.001))
-    (should (equal (eshell-convert-to-number (concat "-.1" exp)) -0.001))))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/floating-point/infinite ()
-  "Test that `eshell-convert-to-number' correctly converts infinite floats."
-  (should (equal (eshell-convert-to-number "1.0e+INF") 1.0e+INF))
-  (should (equal (eshell-convert-to-number "2.e+INF") 1.0e+INF))
-  (should (equal (eshell-convert-to-number "-1.0e+INF") -1.0e+INF))
-  (should (equal (eshell-convert-to-number "-2.e+INF") -1.0e+INF)))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/floating-point/nan ()
-  "Test that `eshell-convert-to-number' correctly converts NaNs."
-  (should (equal (eshell-convert-to-number "1.0e+NaN") 1.0e+NaN))
-  (should (equal (eshell-convert-to-number "2.e+NaN") 2.0e+NaN))
-  (should (equal (eshell-convert-to-number "-1.0e+NaN") -1.0e+NaN))
-  (should (equal (eshell-convert-to-number "-2.e+NaN") -2.0e+NaN)))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/non-numeric ()
-  "Test that `eshell-convert-to-number' does nothing to non-numeric values."
-  (should (equal (eshell-convert-to-number "foo") "foo"))
-  (should (equal (eshell-convert-to-number "") ""))
-  (should (equal (eshell-convert-to-number "123foo") "123foo")))
-
-(ert-deftest esh-util-test/eshell-convert-to-number/no-convert ()
-  "Test that `eshell-convert-to-number' does nothing when disabled."
+    (should (eshell-convertible-to-number-p (concat "123" exp)))
+    (should (eshell-convertible-to-number-p (concat "-123" exp)))
+    (should (eshell-convertible-to-number-p (concat "1.23" exp)))
+    (should (eshell-convertible-to-number-p (concat "-1.23" exp)))
+    (should (eshell-convertible-to-number-p (concat "1." exp)))
+    (should (eshell-convertible-to-number-p (concat "-1." exp)))
+    (should (eshell-convertible-to-number-p (concat ".1" exp)))
+    (should (eshell-convertible-to-number-p (concat "-.1" exp)))))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/float/infinite ()
+  "Test that `eshell-convertible-to-number-p' matches infinite floats."
+  (should (eshell-convertible-to-number-p "1.0e+INF"))
+  (should (eshell-convertible-to-number-p "2.e+INF"))
+  (should (eshell-convertible-to-number-p "-1.0e+INF"))
+  (should (eshell-convertible-to-number-p "-2.e+INF")))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/float/nan ()
+  "Test that `eshell-convertible-to-number-p' matches NaNs."
+  (should (eshell-convertible-to-number-p "1.0e+NaN"))
+  (should (eshell-convertible-to-number-p "2.e+NaN"))
+  (should (eshell-convertible-to-number-p "-1.0e+NaN"))
+  (should (eshell-convertible-to-number-p "-2.e+NaN")))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/non-numeric ()
+  "Test that `eshell-convertible-to-number-p' returns nil for non-numerics."
+  (should-not (eshell-convertible-to-number-p "foo"))
+  (should-not (eshell-convertible-to-number-p ""))
+  (should-not (eshell-convertible-to-number-p "123foo")))
+
+(ert-deftest esh-util-test/eshell-convertible-to-number-p/no-convert ()
+  "Test that `eshell-convertible-to-number-p' returns nil when disabled."
   (let ((eshell-convert-numeric-arguments nil))
-    (should (equal (eshell-convert-to-number "123") "123"))
-    (should (equal (eshell-convert-to-number "1.23") "1.23"))))
+    (should-not (eshell-convertible-to-number-p "123"))
+    (should-not (eshell-convertible-to-number-p "1.23"))))
 
 (ert-deftest esh-util-test/eshell-printable-size ()
   (should (equal (eshell-printable-size (expt 2 16)) "65536"))
diff --git a/test/lisp/eshell/esh-var-tests.el b/test/lisp/eshell/esh-var-tests.el
index 7ac9807a1a7..70f6e9c7777 100644
--- a/test/lisp/eshell/esh-var-tests.el
+++ b/test/lisp/eshell/esh-var-tests.el
@@ -231,7 +231,7 @@ nil, use FUNCTION instead."
     ;; into the first value of the non-spliced list.
     (eshell-command-result-equal
      "echo it is $@'eshell-test-value'$eshell-test-value"
-     '("it" "is" 1 2 (31 2 3)))))
+     '("it" "is" 1 2 ("31" 2 3)))))
 
 (ert-deftest esh-var-test/interp-lisp ()
   "Interpolate Lisp form evaluation."
@@ -280,12 +280,16 @@ nil, use FUNCTION instead."
   (eshell-command-result-equal "+ ${+ 1 2}3 3" 36)
   (eshell-command-result-equal "echo ${*echo \"foo\nbar\"}-baz"
                                '("foo" "bar-baz"))
-  ;; Concatenating to a number in a list should produce a number...
+  ;; Concatenating to a number in a list should produce a numeric value...
   (eshell-command-result-equal "echo ${*echo \"1\n2\"}3"
+                               '("1" "23"))
+  (eshell-command-result-equal "echo $@{*echo \"1\n2\"}3"
                                '(1 23))
   ;; ... but concatenating to a string that looks like a number in a list
   ;; should produce a string.
   (eshell-command-result-equal "echo ${*echo \"hi\n2\"}3"
+                               '("hi" "23"))
+  (eshell-command-result-equal "echo $@{*echo \"hi\n2\"}3"
                                '("hi" "23")))
 
 (ert-deftest esh-var-test/interp-concat-cmd2 ()
@@ -491,11 +495,16 @@ nil, use FUNCTION instead."
 
 (ert-deftest esh-var-test/interp-convert-var-split-indices ()
   "Interpolate and convert string variable with indices."
-  ;; Check that numeric forms are converted to numbers.
+  ;; Check that numeric forms are marked as numeric.
   (let ((eshell-test-value "000 010 020 030 040"))
+    ;; `eshell/echo' converts numeric strings to Lisp numbers...
     (eshell-command-result-equal "echo $eshell-test-value[0]"
                                  0)
+    ;; ... but not lists of numeric strings...
     (eshell-command-result-equal "echo $eshell-test-value[0 2]"
+                                 '("000" "020"))
+    ;; ... unless each element is a separate argument to `eshell/echo'.
+    (eshell-command-result-equal "echo $@eshell-test-value[0 2]"
                                  '(0 20)))
   ;; Check that multiline forms are preserved as-is.
   (let ((eshell-test-value "foo\nbar:baz\n"))
@@ -515,9 +524,14 @@ nil, use FUNCTION instead."
 (ert-deftest esh-var-test/interp-convert-quoted-var-split-indices ()
   "Interpolate and convert quoted string variable with indices."
   (let ((eshell-test-value "000 010 020 030 040"))
+    ;; `eshell/echo' converts numeric strings to Lisp numbers...
     (eshell-command-result-equal "echo $'eshell-test-value'[0]"
                                  0)
+    ;; ... but not lists of numeric strings...
     (eshell-command-result-equal "echo $'eshell-test-value'[0 2]"
+                                 '("000" "020"))
+    ;; ... unless each element is a separate argument to `eshell/echo'.
+    (eshell-command-result-equal "echo $@'eshell-test-value'[0 2]"
                                  '(0 20))))
 
 (ert-deftest esh-var-test/interp-convert-cmd-string-newline ()
@@ -530,9 +544,13 @@ nil, use FUNCTION instead."
                                '("foo" "bar"))
   ;; Numeric output should be converted to numbers...
   (eshell-command-result-equal "echo ${echo \"01\n02\n03\"}"
+                               '("01" "02" "03"))
+  (eshell-command-result-equal "echo $@{echo \"01\n02\n03\"}"
                                '(1 2 3))
   ;; ... but only if every line is numeric.
   (eshell-command-result-equal "echo ${echo \"01\n02\nhi\"}"
+                               '("01" "02" "hi"))
+  (eshell-command-result-equal "echo $@{echo \"01\n02\nhi\"}"
                                '("01" "02" "hi")))
 
 (ert-deftest esh-var-test/interp-convert-cmd-number ()
@@ -541,9 +559,14 @@ nil, use FUNCTION instead."
 
 (ert-deftest esh-var-test/interp-convert-cmd-split-indices ()
   "Interpolate command result with indices."
+  ;; `eshell/echo' converts numeric strings to Lisp numbers...
   (eshell-command-result-equal "echo ${echo \"000 010 020\"}[0]"
                                0)
+  ;; ... but not lists of numeric strings...
   (eshell-command-result-equal "echo ${echo \"000 010 020\"}[0 2]"
+                               '("000" "020"))
+  ;; ... unless each element is a separate argument to `eshell/echo'.
+  (eshell-command-result-equal "echo $@{echo \"000 010 020\"}[0 2]"
                                '(0 20)))
 
 (ert-deftest esh-var-test/quoted-interp-convert-var-number ()