feat(rust-cli): wire IFS word splitting into for-loops and read builtin

Two key POSIX §2.6.5 integration points for $IFS word splitting:

1. **for-loop word list** — `for x in $var; do ... done` now expands
   each word in the `in` clause, then applies `ifs_split` using the
   current `$IFS` (defaulting to space/tab/newline). This means
   `ITEMS="a b c"; for x in $ITEMS; do mkdir $x; done` creates three
   directories instead of one named "a b c".

2. **read builtin** — `read a b c` now splits stdin input by `$IFS`
   and assigns fields to named variables. The last variable receives
   the remainder (POSIX behaviour). The parser now collects multiple
   variable names instead of just one. `read` with no args still
   defaults to `$REPLY`.

The existing `ifs_split()` function in posix_builtins.rs (which had
full POSIX semantics — whitespace/non-whitespace IFS handling, empty
IFS preventing splitting, leading/trailing delimiter handling) was
already tested but not wired into any execution path. Now it is.

Tests: 8 new tests covering default IFS, custom IFS (comma-separated),
empty IFS, newline splitting, literal word lists, and multi-variable
read parsing.

Test results: 729 passing, 0 failing, 14 ignored (up from 721).

https://claude.ai/code/session_01EMHrh5Jq32pb98KXoSKLA4

Author: claude

impl/rust-cli/src/executable.rs

@@ -674,9 +674,7 @@ impl ExecutableCommand for Command {
                 Ok(ExecutionResult::ExternalCommand { exit_code: 1 })
             }
 
-            Command::Read { var_name, prompt, redirects: _ } => {
-                let expanded_var = crate::parser::expand_variables(var_name, state);
-
+            Command::Read { var_names, prompt, redirects: _ } => {
                 if let Some(p) = prompt {
                     let expanded_prompt = crate::parser::expand_variables(p, state);
                     eprint!("{}", expanded_prompt);
@@ -691,7 +689,41 @@ impl ExecutableCommand for Command {
                     }
                     Ok(_) => {
                         let value = input.trim_end_matches('\n').trim_end_matches('\r');
-                        state.set_variable(expanded_var, value.to_string());
+
+                        // POSIX §2.21: split by IFS, assign fields to vars.
+                        // The last variable gets the remainder (including
+                        // any fields beyond the variable count).
+                        let ifs = state
+                            .get_variable("IFS")
+                            .map(|s| s.to_string())
+                            .unwrap_or_else(|| {
+                                crate::posix_builtins::DEFAULT_IFS.to_string()
+                            });
+
+                        let fields = crate::posix_builtins::ifs_split(value, &ifs);
+
+                        for (i, var_name) in var_names.iter().enumerate() {
+                            let expanded_var =
+                                crate::parser::expand_variables(var_name, state);
+                            if i == var_names.len() - 1 {
+                                // Last variable gets the remainder.
+                                // Rejoin un-consumed fields with a single
+                                // space (POSIX behaviour).
+                                let remainder = if i < fields.len() {
+                                    fields[i..].join(" ")
+                                } else {
+                                    String::new()
+                                };
+                                state.set_variable(expanded_var, remainder);
+                            } else {
+                                let field = fields
+                                    .get(i)
+                                    .cloned()
+                                    .unwrap_or_default();
+                                state.set_variable(expanded_var, field);
+                            }
+                        }
+
                         Ok(ExecutionResult::Success)
                     }
                     Err(e) => Err(anyhow::anyhow!("read: {}", e)),
@@ -891,11 +923,24 @@ impl ExecutableCommand for Command {
             Command::ForLoop { var, words, body } => {
                 let mut last_result = ExecutionResult::Success;
 
-                for word in words {
-                    // Expand variables in the word
-                    let expanded = crate::parser::expand_variables(word, state);
+                // POSIX §2.6.5: expand each word, then apply IFS splitting
+                // to produce the actual iteration list.
+                let ifs = state
+                    .get_variable("IFS")
+                    .map(|s| s.to_string())
+                    .unwrap_or_else(|| crate::posix_builtins::DEFAULT_IFS.to_string());
+
+                let expanded_words: Vec<String> = words
+                    .iter()
+                    .flat_map(|word| {
+                        let expanded = crate::parser::expand_variables(word, state);
+                        crate::posix_builtins::ifs_split(&expanded, &ifs)
+                    })
+                    .collect();
+
+                for word in &expanded_words {
                     // Set loop variable
-                    state.set_variable(var.clone(), expanded);
+                    state.set_variable(var.clone(), word.clone());
 
                     // Execute body
                     last_result = execute_block(body, state)?;
@@ -1282,7 +1327,7 @@ impl ExecutableCommand for Command {
             Command::Echo { args, .. } => format!("echo {}", args.join(" ")),
             Command::True => "true".to_string(),
             Command::False => "false".to_string(),
-            Command::Read { var_name, .. } => format!("read {}", var_name),
+            Command::Read { var_names, .. } => format!("read {}", var_names.join(" ")),
             Command::Source { file } => format!("source {}", file),
             Command::Set { args } => format!("set {}", args.join(" ")),
             Command::Unset { name } => format!("unset {}", name),

impl/rust-cli/src/parser.rs

@@ -294,9 +294,9 @@ pub enum Command {
     True,
     /// false: always returns exit code 1
     False,
-    /// read: read a line from stdin into a variable
+    /// read: read a line from stdin, split by IFS, assign to variables
     Read {
-        var_name: String,
+        var_names: Vec<String>,
         prompt: Option<String>,
         redirects: Vec<Redirection>,
     },
@@ -3446,23 +3446,23 @@ fn parse_base_command(cmd: &str, args: Vec<String>, redirects: Vec<Redirection>,
         ":" => Ok(Command::True), // POSIX no-op, same as true
 
         "read" => {
-            // read [-p prompt] var_name
-            let mut var_name = String::new();
+            // read [-p prompt] var1 [var2 ...]
+            let mut var_names: Vec<String> = Vec::new();
             let mut prompt = None;
             let mut i = 0;
             while i < args.len() {
                 if args[i] == "-p" && i + 1 < args.len() {
                     prompt = Some(args[i + 1].clone());
                     i += 2;
                 } else {
-                    var_name = args[i].clone();
+                    var_names.push(args[i].clone());
                     i += 1;
                 }
             }
-            if var_name.is_empty() {
-                var_name = "REPLY".to_string();
+            if var_names.is_empty() {
+                var_names.push("REPLY".to_string());
             }
-            Ok(Command::Read { var_name, prompt, redirects })
+            Ok(Command::Read { var_names, prompt, redirects })
         }
 
         "source" | "." => {

impl/rust-cli/tests/ifs_splitting_tests.rs

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+//! Tests for IFS word splitting in for-loops and related contexts.
+//!
+//! POSIX §2.6.5 says that after parameter expansion, the result of
+//! unquoted expansions is split into fields using `$IFS`.  This affects
+//! the `for ... in $words` word list (each expanded word is split) and
+//! the `read` builtin (input is split across named variables).
+
+use anyhow::Result;
+use tempfile::tempdir;
+use vsh::executable::ExecutableCommand;
+use vsh::parser::parse_command;
+use vsh::state::ShellState;
+
+// -------------------------------------------------------------------------
+// IFS splitting in for-loops
+// -------------------------------------------------------------------------
+
+#[test]
+fn for_loop_splits_variable_by_default_ifs() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    state.set_variable("ITEMS", "alpha beta gamma");
+
+    parse_command("for x in $ITEMS; do mkdir $x; done")?
+        .execute(&mut state)?;
+
+    assert!(state.resolve_path("alpha").exists());
+    assert!(state.resolve_path("beta").exists());
+    assert!(state.resolve_path("gamma").exists());
+    Ok(())
+}
+
+#[test]
+fn for_loop_splits_variable_by_custom_ifs() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    state.set_variable("CSV", "one,two,three");
+    state.set_variable("IFS", ",");
+
+    parse_command("for x in $CSV; do mkdir $x; done")?
+        .execute(&mut state)?;
+
+    assert!(state.resolve_path("one").exists());
+    assert!(state.resolve_path("two").exists());
+    assert!(state.resolve_path("three").exists());
+    Ok(())
+}
+
+#[test]
+fn for_loop_with_empty_ifs_does_not_split() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    state.set_variable("WORDS", "hello world");
+    state.set_variable("IFS", "");
+
+    // With empty IFS, the entire value is one word.
+    // The for-loop body runs once and creates one dir whose name
+    // contains a space.
+    parse_command("for x in $WORDS; do mkdir $x; done")?
+        .execute(&mut state)?;
+
+    // "hello world" stays as one token — but mkdir may receive it as
+    // two words due to the shell's argument tokenization. The key test
+    // is that IFS="" prevents the for-loop from splitting the expansion
+    // into two iterations.
+    //
+    // Verify we did NOT get separate "hello" and "world" directories.
+    assert!(!state.resolve_path("hello").exists());
+    assert!(!state.resolve_path("world").exists());
+    Ok(())
+}
+
+#[test]
+fn for_loop_splits_newlines_in_variable() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    // Newline is part of default IFS
+    state.set_variable("LINES", "line1\nline2\nline3");
+
+    parse_command("for x in $LINES; do mkdir $x; done")?
+        .execute(&mut state)?;
+
+    assert!(state.resolve_path("line1").exists());
+    assert!(state.resolve_path("line2").exists());
+    assert!(state.resolve_path("line3").exists());
+    Ok(())
+}
+
+#[test]
+fn for_loop_literal_words_not_affected_by_ifs() -> Result<()> {
+    let temp = tempdir()?;
+    let mut state = ShellState::new(temp.path().to_str().unwrap())?;
+
+    // Literal words in the for-list are already split by the parser
+    // at whitespace boundaries. IFS affects EXPANSION splitting, not
+    // literal splitting.
+    parse_command("for x in one two three; do mkdir $x; done")?
+        .execute(&mut state)?;
+
+    assert!(state.resolve_path("one").exists());
+    assert!(state.resolve_path("two").exists());
+    assert!(state.resolve_path("three").exists());
+    Ok(())
+}
+
+// -------------------------------------------------------------------------
+// read builtin: IFS splitting + multiple variables
+// -------------------------------------------------------------------------
+
+// Note: The `read` builtin reads from stdin, which we can't easily mock in
+// integration tests. We test the parser changes and IFS logic indirectly
+// through the unit tests in posix_builtins.rs and by verifying the Command
+// variant is parsed correctly.
+
+#[test]
+fn read_parses_multiple_variables() -> Result<()> {
+    let cmd = parse_command("read a b c")?;
+    let desc = format!("{:?}", cmd);
+    // Should have three variable names
+    assert!(desc.contains("var_names"));
+    assert!(desc.contains("\"a\""));
+    assert!(desc.contains("\"b\""));
+    assert!(desc.contains("\"c\""));
+    Ok(())
+}
+
+#[test]
+fn read_defaults_to_reply() -> Result<()> {
+    let cmd = parse_command("read")?;
+    let desc = format!("{:?}", cmd);
+    assert!(desc.contains("REPLY"));
+    Ok(())
+}
+
+#[test]
+fn read_with_prompt_and_vars() -> Result<()> {
+    let cmd = parse_command("read -p 'Enter: ' first last")?;
+    let desc = format!("{:?}", cmd);
+    assert!(desc.contains("\"first\""));
+    assert!(desc.contains("\"last\""));
+    assert!(desc.contains("Enter:"));
+    Ok(())
+}