Fix replacement closures for update, insert, and upsert (#11258)

# Description
This PR addresses #11204 which points out that using a closure for the
replacement value with `update`, `insert`, or `upsert` does not work for
lists.

# User-Facing Changes
- Replacement closures should now work for lists in `upsert`, `insert`,
and `update`. E.g., `[0] | update 0 {|i| $i + 1 }` now gives `[1]`
instead of an unhelpful error.
- `[1 2] | insert 4 20` no longer works. Before, this would give `[1, 2,
null, null, 20]`, but now it gives an error. This was done to match the
intended behavior in `Value::insert_data_at_cell_path`, whereas the
behavior before was probably unintentional. Following
`Value::insert_data_at_cell_path`, inserting at the end of a list is
also fine, so the valid indices for `upsert` and `insert` are
`0..=length` just like `Vec::insert` or list inserts in other languages.

# Tests + Formatting
Added tests for `upsert`, `insert`, and `update`:
- Replacement closures for lists, list streams, records, and tables
- Other list stream tests

crates/nu-command/tests/commands/insert.rs

@@ -44,24 +44,49 @@ fn insert_into_list() {
 }
 
 #[test]
-fn insert_into_list_begin() {
+fn insert_at_start_of_list() {
     let actual = nu!("[1, 2, 3] | insert 0 abc | to json -r");
 
     assert_eq!(actual.out, r#"["abc",1,2,3]"#);
 }
 
 #[test]
-fn insert_into_list_end() {
+fn insert_at_end_of_list() {
     let actual = nu!("[1, 2, 3] | insert 3 abc | to json -r");
 
     assert_eq!(actual.out, r#"[1,2,3,"abc"]"#);
 }
 
 #[test]
-fn insert_past_end_list() {
-    let actual = nu!("[1, 2, 3] | insert 5 abc | to json -r");
+fn insert_past_end_of_list() {
+    let actual = nu!("[1, 2, 3] | insert 5 abc");
 
-    assert_eq!(actual.out, r#"[1,2,3,null,null,"abc"]"#);
+    assert!(actual
+        .err
+        .contains("can't insert at index (the next available index is 3)"));
+}
+
+#[test]
+fn insert_into_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | insert 1 abc | to json -r");
+
+    assert_eq!(actual.out, r#"[1,"abc",2,3]"#);
+}
+
+#[test]
+fn insert_at_end_of_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | insert 3 abc | to json -r");
+
+    assert_eq!(actual.out, r#"[1,2,3,"abc"]"#);
+}
+
+#[test]
+fn insert_past_end_of_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | insert 5 abc");
+
+    assert!(actual
+        .err
+        .contains("can't insert at index (the next available index is 3)"));
 }
 
 #[test]
@@ -90,14 +115,82 @@ fn lazy_record_test_values() {
 
 #[test]
 fn deep_cell_path_creates_all_nested_records() {
-    let actual = nu!(r#"{a: {}} | insert a.b.c 0 | get a.b.c"#);
+    let actual = nu!("{a: {}} | insert a.b.c 0 | get a.b.c");
     assert_eq!(actual.out, "0");
 }
 
 #[test]
 fn inserts_all_rows_in_table_in_record() {
     let actual = nu!(
-        r#"{table: [[col]; [{a: 1}], [{a: 1}]]} | insert table.col.b 2 | get table.col.b | to nuon"#
+        "{table: [[col]; [{a: 1}], [{a: 1}]]} | insert table.col.b 2 | get table.col.b | to nuon"
     );
     assert_eq!(actual.out, "[2, 2]");
 }
+
+#[test]
+fn list_replacement_closure() {
+    let actual = nu!("[1, 2] | insert 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3, 2]");
+
+    let actual = nu!("[1, 2] | insert 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3, 2]");
+
+    let actual = nu!("[1, 2] | insert 2 {|i| if $i == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual = nu!("[1, 2] | insert 2 { if $in == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+}
+
+#[test]
+fn record_replacement_closure() {
+    let actual = nu!("{ a: text } | insert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: text, b: TEXT}");
+
+    let actual = nu!("{ a: text } | insert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "{a: text, b: TEXT}");
+
+    let actual = nu!("{ a: { b: 1 } } | insert a.c {|r| $r.a.b } | to nuon");
+    assert_eq!(actual.out, "{a: {b: 1, c: 1}}");
+
+    let actual = nu!("{ a: { b: 1 } } | insert a.c { default 0 } | to nuon");
+    assert_eq!(actual.out, "{a: {b: 1, c: 0}}");
+}
+
+#[test]
+fn table_replacement_closure() {
+    let actual = nu!("[[a]; [text]] | insert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | insert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[b]; [1]] | wrap a | insert a.c {|r| $r.a.b } | to nuon");
+    assert_eq!(actual.out, "[[a]; [{b: 1, c: 1}]]");
+
+    let actual = nu!("[[b]; [1]] | wrap a | insert a.c { default 0 } | to nuon");
+    assert_eq!(actual.out, "[[a]; [{b: 1, c: 0}]]");
+}
+
+#[test]
+fn list_stream_replacement_closure() {
+    let actual = nu!("[1, 2] | every 1 | insert 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3, 2]");
+
+    let actual = nu!("[1, 2] | every 1 | insert 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3, 2]");
+
+    let actual =
+        nu!("[1, 2] | every 1 | insert 2 {|i| if $i == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual =
+        nu!("[1, 2] | every 1 | insert 2 { if $in == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | insert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | insert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+}

crates/nu-command/tests/commands/update.rs

@@ -71,11 +71,23 @@ fn update_list() {
 }
 
 #[test]
-fn update_past_end_list() {
+fn update_past_end_of_list() {
     let actual = nu!("[1, 2, 3] | update 5 abc | to json -r");
     assert!(actual.err.contains("too large"));
 }
 
+#[test]
+fn update_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | update 1 abc | to json -r");
+    assert_eq!(actual.out, r#"[1,"abc",3]"#);
+}
+
+#[test]
+fn update_past_end_of_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | update 5 abc | to json -r");
+    assert!(actual.err.contains("too large"));
+}
+
 #[test]
 fn update_nonexistent_column() {
     let actual = nu!("{a:1} | update b 2");
@@ -85,7 +97,7 @@ fn update_nonexistent_column() {
 #[test]
 fn update_uses_enumerate_index() {
     let actual = nu!(
-        r#"[[a]; [7] [6]] | enumerate | update item.a {|el| $el.index + 1 + $el.item.a } | flatten | to nuon"#
+        "[[a]; [7] [6]] | enumerate | update item.a {|el| $el.index + 1 + $el.item.a } | flatten | to nuon"
     );
 
     assert_eq!(actual.out, "[[index, a]; [0, 8], [1, 8]]");
@@ -97,3 +109,45 @@ fn update_support_lazy_record() {
         nu!(r#"let x = (lazy make -c ["h"] -g {|a| $a | str upcase}); $x | update h 10 | get h"#);
     assert_eq!(actual.out, "10");
 }
+
+#[test]
+fn list_replacement_closure() {
+    let actual = nu!("[1, 2] | update 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[1, 2] | update 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+}
+
+#[test]
+fn record_replacement_closure() {
+    let actual = nu!("{ a: text } | update a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: TEXT}");
+
+    let actual = nu!("{ a: text } | update a { str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: TEXT}");
+}
+
+#[test]
+fn table_replacement_closure() {
+    let actual = nu!("[[a]; [text]] | update a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | update a { str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+}
+
+#[test]
+fn list_stream_replacement_closure() {
+    let actual = nu!("[1, 2] | every 1 | update 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[1, 2] | every 1 | update 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | update a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | update a { str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+}

crates/nu-command/tests/commands/upsert.rs

@@ -67,17 +67,49 @@ fn upsert_uses_enumerate_index_updating() {
 }
 
 #[test]
-fn index_does_not_exist() {
-    let actual = nu!("[1,2,3] | upsert 4 4");
+fn upsert_into_list() {
+    let actual = nu!("[1, 2, 3] | upsert 1 abc | to json -r");
 
-    assert!(actual.err.contains("index too large (max: 3)"));
+    assert_eq!(actual.out, r#"[1,"abc",3]"#);
 }
 
 #[test]
-fn upsert_empty() {
-    let actual = nu!("[] | upsert 1 1");
+fn upsert_at_end_of_list() {
+    let actual = nu!("[1, 2, 3] | upsert 3 abc | to json -r");
 
-    assert!(actual.err.contains("index too large (max: 0)"));
+    assert_eq!(actual.out, r#"[1,2,3,"abc"]"#);
+}
+
+#[test]
+fn upsert_past_end_of_list() {
+    let actual = nu!("[1, 2, 3] | upsert 5 abc");
+
+    assert!(actual
+        .err
+        .contains("can't insert at index (the next available index is 3)"));
+}
+
+#[test]
+fn upsert_into_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | upsert 1 abc | to json -r");
+
+    assert_eq!(actual.out, r#"[1,"abc",3]"#);
+}
+
+#[test]
+fn upsert_at_end_of_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | upsert 3 abc | to json -r");
+
+    assert_eq!(actual.out, r#"[1,2,3,"abc"]"#);
+}
+
+#[test]
+fn upsert_past_end_of_list_stream() {
+    let actual = nu!("[1, 2, 3] | every 1 | upsert 5 abc");
+
+    assert!(actual
+        .err
+        .contains("can't insert at index (the next available index is 3)"));
 }
 
 #[test]
@@ -93,14 +125,100 @@ fn upsert_support_lazy_record() {
 
 #[test]
 fn deep_cell_path_creates_all_nested_records() {
-    let actual = nu!(r#"{a: {}} | insert a.b.c 0 | get a.b.c"#);
+    let actual = nu!("{a: {}} | upsert a.b.c 0 | get a.b.c");
     assert_eq!(actual.out, "0");
 }
 
 #[test]
 fn upserts_all_rows_in_table_in_record() {
     let actual = nu!(
-        r#"{table: [[col]; [{a: 1}], [{a: 1}]]} | insert table.col.b 2 | get table.col.b | to nuon"#
+        "{table: [[col]; [{a: 1}], [{a: 1}]]} | upsert table.col.b 2 | get table.col.b | to nuon"
     );
     assert_eq!(actual.out, "[2, 2]");
 }
+
+#[test]
+fn list_replacement_closure() {
+    let actual = nu!("[1, 2] | upsert 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[1, 2] | upsert 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[1, 2] | upsert 2 {|i| if $i == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual = nu!("[1, 2] | upsert 2 { if $in == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+}
+
+#[test]
+fn record_replacement_closure() {
+    let actual = nu!("{ a: text } | upsert a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: TEXT}");
+
+    let actual = nu!("{ a: text } | upsert a { str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: TEXT}");
+
+    let actual = nu!("{ a: text } | upsert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "{a: text, b: TEXT}");
+
+    let actual = nu!("{ a: text } | upsert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "{a: text, b: TEXT}");
+
+    let actual = nu!("{ a: { b: 1 } } | upsert a.c {|r| $r.a.b } | to nuon");
+    assert_eq!(actual.out, "{a: {b: 1, c: 1}}");
+
+    let actual = nu!("{ a: { b: 1 } } | upsert a.c { default 0 } | to nuon");
+    assert_eq!(actual.out, "{a: {b: 1, c: 0}}");
+}
+
+#[test]
+fn table_replacement_closure() {
+    let actual = nu!("[[a]; [text]] | upsert a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | upsert a { str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | upsert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | upsert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[b]; [1]] | wrap a | upsert a.c {|r| $r.a.b } | to nuon");
+    assert_eq!(actual.out, "[[a]; [{b: 1, c: 1}]]");
+
+    let actual = nu!("[[b]; [1]] | wrap a | upsert a.c { default 0 } | to nuon");
+    assert_eq!(actual.out, "[[a]; [{b: 1, c: 0}]]");
+}
+
+#[test]
+fn list_stream_replacement_closure() {
+    let actual = nu!("[1, 2] | every 1 | upsert 1 {|i| $i + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual = nu!("[1, 2] | every 1 | upsert 1 { $in + 1 } | to nuon");
+    assert_eq!(actual.out, "[1, 3]");
+
+    let actual =
+        nu!("[1, 2] | every 1 | upsert 2 {|i| if $i == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual =
+        nu!("[1, 2] | every 1 | upsert 2 { if $in == null { 0 } else { $in + 1 } } | to nuon");
+    assert_eq!(actual.out, "[1, 2, 0]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | upsert a {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | upsert a { str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a]; [TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | upsert b {|r| $r.a | str upcase } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+
+    let actual = nu!("[[a]; [text]] | every 1 | upsert b { default TEXT } | to nuon");
+    assert_eq!(actual.out, "[[a, b]; [text, TEXT]]");
+}