chore: minor cleanups and test additions (#364)

Add more tests for FUNCNAME and LINENO well-known variables.

brush-core/src/builtins/colon.rs

@@ -18,9 +18,9 @@ impl builtins::SimpleCommand for ColonCommand {
         }
     }
 
-    fn execute(
+    fn execute<I: Iterator<Item = S>, S: AsRef<str>>(
         _context: commands::ExecutionContext<'_>,
-        _args: &[&str],
+        _args: I,
     ) -> Result<builtins::BuiltinResult, crate::error::Error> {
         Ok(builtins::BuiltinResult {
             exit_code: builtins::ExitCode::Success,

brush-core/src/builtins/declare.rs

@@ -208,7 +208,8 @@ impl DeclareCommand {
                 cs.push('-');
             }
 
-            let separator_str = if matches!(variable.value(), ShellValue::Unset(_)) {
+            let resolved_value = variable.resolve_value(context.shell);
+            let separator_str = if matches!(resolved_value, ShellValue::Unset(_)) {
                 ""
             } else {
                 "="
@@ -217,9 +218,7 @@ impl DeclareCommand {
             writeln!(
                 context.stdout(),
                 "declare -{cs} {name}{separator_str}{}",
-                variable
-                    .value()
-                    .format(variables::FormatStyle::DeclarePrint, context.shell)?
+                resolved_value.format(variables::FormatStyle::DeclarePrint, context.shell)?
             )?;
 
             Ok(true)

brush-core/src/builtins/dirs.rs

@@ -4,7 +4,7 @@ use std::io::Write;
 use crate::{builtins, commands};
 
 /// Manage the current directory stack.
-#[derive(Parser, Debug, Default)]
+#[derive(Default, Parser)]
 pub(crate) struct DirsCommand {
     /// Clear the directory stack.
     #[arg(short = 'c')]

brush-core/src/builtins/dot.rs

@@ -5,7 +5,7 @@ use clap::Parser;
 use crate::{builtins, commands};
 
 /// Evalute the provided script in the current shell environment.
-#[derive(Debug, Parser)]
+#[derive(Parser)]
 pub(crate) struct DotCommand {
     /// Path to the script to evaluate.
     script_path: String,

brush-core/src/builtins/factory.rs

@@ -16,9 +16,9 @@ pub trait SimpleCommand {
         -> Result<String, error::Error>;
 
     /// Executes the built-in command.
-    fn execute(
+    fn execute<I: Iterator<Item = S>, S: AsRef<str>>(
         context: commands::ExecutionContext<'_>,
-        args: &[&str],
+        args: I,
     ) -> Result<builtins::BuiltinResult, error::Error>;
 }
 
@@ -75,17 +75,12 @@ async fn exec_simple_builtin_impl<T: SimpleCommand + Send + Sync>(
     context: commands::ExecutionContext<'_>,
     args: Vec<CommandArg>,
 ) -> Result<builtins::BuiltinResult, error::Error> {
-    let plain_args: Vec<_> = args
-        .into_iter()
-        .map(|arg| match arg {
-            CommandArg::String(s) => s,
-            CommandArg::Assignment(a) => a.to_string(),
-        })
-        .collect();
-
-    let plain_args: Vec<_> = plain_args.iter().map(AsRef::as_ref).collect();
+    let plain_args = args.into_iter().map(|arg| match arg {
+        CommandArg::String(s) => s,
+        CommandArg::Assignment(a) => a.to_string(),
+    });
 
-    T::execute(context, plain_args.as_slice())
+    T::execute(context, plain_args)
 }
 
 fn exec_builtin<T: builtins::Command + Send + Sync>(

brush-core/src/shell.rs

@@ -58,12 +58,12 @@ pub struct Shell {
     /// Clone depth from the original ancestor shell.
     depth: usize,
 
-    /// Positional parameters ($1 and beyond)
-    pub positional_parameters: Vec<String>,
-
-    /// Shell name
+    /// Shell name (a.k.a. $0)
     pub shell_name: Option<String>,
 
+    /// Positional parameters stack ($1 and beyond)
+    pub positional_parameters: Vec<String>,
+
     /// Detailed display string for the shell
     pub shell_product_display_str: Option<String>,
 
@@ -298,6 +298,7 @@ impl Shell {
             }),
         )?;
 
+        // TODO(vars): when extdebug is enabled, BASH_ARGC and BASH_ARGV are set to valid values
         // TODO(vars): implement BASH_ARGC
         // TODO(vars): implement BASH_ARGV
 
@@ -1199,11 +1200,15 @@ impl Shell {
     }
 
     fn get_funcname_value(&self) -> variables::ShellValue {
-        self.function_call_stack
-            .iter()
-            .map(|s| s.function_name.as_str())
-            .collect::<Vec<_>>()
-            .into()
+        if self.function_call_stack.is_empty() {
+            ShellValue::Unset(variables::ShellValueUnsetType::IndexedArray)
+        } else {
+            self.function_call_stack
+                .iter()
+                .map(|s| s.function_name.as_str())
+                .collect::<Vec<_>>()
+                .into()
+        }
     }
 
     fn get_bash_source_value(&self) -> variables::ShellValue {

brush-core/src/variables.rs

@@ -484,7 +484,12 @@ impl ShellVariable {
         }
     }
 
-    fn resolve_value(&self, shell: &Shell) -> ShellValue {
+    /// Returns the variable's value; for dynamic values, this will resolve the value.
+    ///
+    /// # Arguments
+    ///
+    /// * `shell` - The shell in which the variable is being resolved.
+    pub(crate) fn resolve_value(&self, shell: &Shell) -> ShellValue {
         // N.B. We do *not* specially handle a dynamic value that resolves to a dynamic value.
         match &self.value {
             ShellValue::Dynamic { getter, .. } => getter(shell),

brush-shell/tests/cases/well_known_vars.yaml

@@ -46,6 +46,23 @@ cases:
 
       echo "BASHOPTS: $BASHOPTS"
 
+  - name: "BASH_SOURCE and FUNCNAME"
+    stdin: |
+      echo "Input entry"; declare -p BASH_SOURCE FUNCNAME
+
+      function myfunc() {
+          echo "In function: \$1: $1"
+          declare -p BASH_SOURCE FUNCNAME
+
+          if [[ $1 -gt 0 ]]; then
+              myfunc $(( $1 - 1 ))
+          fi
+      }
+
+      myfunc 4
+
+      echo "Input exit"; declare -p BASH_SOURCE FUNCNAME
+
   - name: "BASH_SUBSHELL"
     stdin: |
       echo "Initial BASH_SUBSHELL: $BASH_SUBSHELL"
@@ -96,6 +113,19 @@ cases:
         echo $group
       done) | sort
 
+  - name: "LINENO"
+    stdin: |
+      echo "LINENO: $LINENO"
+      echo "LINENO: $LINENO"
+      echo "LINENO: $LINENO"
+
+  - name: "LINENO with multi-line input"
+    known_failure: true # Not implemented correctly yet
+    stdin: |
+      for f in 1 2 3; do
+        echo "LINENO: $LINENO"
+      done
+
   - name: "SHELLOPTS"
     stdin: |
       echo "SHELLOPTS: $SHELLOPTS"