Expand "$@" to one word per positional parameter

"$@" expanded to a single word with all positional parameters joined by
spaces, so arguments could not be forwarded intact. Expand it to one word
per parameter, as Bash does: text around it joins the first and last
parameters, and with no parameters "$@" gives no word at all. Unquoted
$@ also gives one word per (non-empty) parameter. shift now updates $@
and $* as well.

Fixes #291

Author: certik

crates/deno_task_shell/src/shell/commands/shift.rs

@@ -70,11 +70,14 @@ impl ShellCommand for ShiftCommand {
             changes.push(EnvChange::UnsetVar(idx.to_string()));
         }
 
-        // Update $# (parameter count)
+        // Update $# (parameter count), $@ and $*
         changes.push(EnvChange::SetShellVar(
             "#".to_string(),
             remaining.len().to_string(),
         ));
+        let joined = remaining.join(" ");
+        changes.push(EnvChange::SetShellVar("@".to_string(), joined.clone()));
+        changes.push(EnvChange::SetShellVar("*".to_string(), joined));
 
         Box::pin(futures::future::ready(ExecuteResult::Continue(
             0,

crates/deno_task_shell/src/shell/execute.rs

@@ -2553,6 +2553,26 @@ fn expand_brace_word_parts(
     Ok(result)
 }
 
+/// Whether a variable expansion is `$@` or `${@}` without a modifier.
+fn is_all_params(
+    name: &str,
+    modifier: &Option<Box<VariableModifier>>,
+    indirect: bool,
+) -> bool {
+    name == "@" && modifier.is_none() && !indirect
+}
+
+/// The positional parameters `$1` to `${N}`, where N is `$#`.
+fn positional_params(state: &ShellState) -> Vec<String> {
+    let count = state
+        .get_var("#")
+        .and_then(|n| n.parse::<usize>().ok())
+        .unwrap_or(0);
+    (1..=count)
+        .map(|i| state.get_var(&i.to_string()).cloned().unwrap_or_default())
+        .collect()
+}
+
 fn evaluate_word_parts(
     parts: Vec<WordPart>,
     state: &mut ShellState,
@@ -2676,7 +2696,8 @@ fn evaluate_word_parts(
         async move {
             let mut result = WordPartsResult::new(Vec::new(), Vec::new());
             let mut current_text = Vec::new();
-            for part in parts {
+            let mut parts = std::collections::VecDeque::from(parts);
+            while let Some(part) = parts.pop_front() {
                 let evaluation_result_text: Result<Option<Text>, Error> =
                     match part {
                         WordPart::Text(text) => {
@@ -2694,7 +2715,18 @@ fn evaluate_word_parts(
                             } else {
                                 name.clone()
                             };
-                            if let Some(modifier) = modifier {
+                            if is_all_params(&resolved_name, &modifier, indirect)
+                            {
+                                // Unquoted $@ expands to one word per
+                                // non-empty positional parameter
+                                Ok(Some(Text::new(
+                                    positional_params(state)
+                                        .into_iter()
+                                        .filter(|p| !p.is_empty())
+                                        .map(OtherText)
+                                        .collect(),
+                                )))
+                            } else if let Some(modifier) = modifier {
                                 let (text, env_changes) = modifier
                                     .apply(
                                         &resolved_name,
@@ -2734,9 +2766,51 @@ fn evaluate_word_parts(
                             .await;
                             Ok(Some(cmd.into()))
                         }
-                        WordPart::Quoted(parts) => {
+                        WordPart::Quoted(mut quoted_parts) => {
+                            // "$@" expands to one word per positional
+                            // parameter: "pre$@post" with parameters a and b
+                            // gives "prea" and "bpost", and with no
+                            // parameters "$@" gives no word at all.
+                            if let Some(idx) = quoted_parts.iter().position(|p| {
+                                matches!(p, WordPart::Variable(name, modifier, indirect)
+                                    if is_all_params(name, modifier, *indirect))
+                            }) {
+                                let after = quoted_parts.split_off(idx + 1);
+                                quoted_parts.pop();
+                                if !quoted_parts.is_empty() {
+                                    let res = evaluate_word_parts_inner(
+                                        quoted_parts,
+                                        IsQuoted::Yes,
+                                        eval_glob,
+                                        state,
+                                        stdin.clone(),
+                                        stderr.clone(),
+                                    )
+                                    .await?;
+                                    result.with_changes(res.changes);
+                                    current_text
+                                        .push(TextPart::Quoted(res.value.join(" ")));
+                                }
+                                let params = positional_params(state);
+                                let count = params.len();
+                                for (i, param) in params.into_iter().enumerate() {
+                                    current_text.push(TextPart::Quoted(param));
+                                    if i + 1 < count {
+                                        result.extend(evaluate_word_text(
+                                            state,
+                                            std::mem::take(&mut current_text),
+                                            is_quoted,
+                                            eval_glob,
+                                        )?);
+                                    }
+                                }
+                                if !after.is_empty() {
+                                    parts.push_front(WordPart::Quoted(after));
+                                }
+                                continue;
+                            }
                             let res = evaluate_word_parts_inner(
-                                parts,
+                                quoted_parts,
                                 IsQuoted::Yes,
                                 eval_glob,
                                 state,

crates/shell/tests/script_args.rs

@@ -52,3 +52,25 @@ echo "all=[$@]"
 "#;
     assert_eq!(run_script("no_args.sh", script, &[]), "count=0\nall=[]\n");
 }
+
+#[test]
+fn script_forwards_arguments() {
+    // "$@" keeps each script argument as a separate word, also after shift
+    let script = r#"build_dir="${1:-.}"
+if [ "$#" -gt 0 ]; then
+    shift
+fi
+echo "build_dir=$build_dir"
+for a in -S . "$@"; do
+    echo "[$a]"
+done
+"#;
+    assert_eq!(
+        run_script("forward.sh", script, &["build", "-DA=1", "-DB=x y"]),
+        "build_dir=build\n[-S]\n[.]\n[-DA=1]\n[-DB=x y]\n"
+    );
+    assert_eq!(
+        run_script("forward_none.sh", script, &[]),
+        "build_dir=.\n[-S]\n[.]\n"
+    );
+}

crates/tests/test-data/functions.sh

@@ -78,3 +78,39 @@ build
 > tenth() { echo "${10:-none}"; }
 > tenth 1 2 3 4 5 6 7 8 9 ten
 ten
+
+# "$@" expands to one word per positional parameter (prefix-dev/shell#291)
+> count() { echo $#; }
+> fwd() { count "$@"; }
+> fwd a 'b c' d
+> fwd
+> fwd ""
+3
+0
+1
+
+> each() { for a in "$@"; do echo "[$a]"; done }
+> each a 'b c'
+[a]
+[b c]
+
+# Text around "$@" joins the first and last parameters
+> words() { for a in "pre$@post"; do echo "[$a]"; done }
+> words a b
+> words
+[prea]
+[bpost]
+[prepost]
+
+# Unquoted $@ also gives one word per parameter
+> count() { echo $#; }
+> fwd() { count $@; }
+> fwd a b c
+3
+
+# shift updates "$@" and "$*"
+> rest() { shift; echo "$*"; for a in "$@"; do echo "[$a]"; done }
+> rest a b 'c d'
+b c d
+[b]
+[c d]