feat: reduce allocations

brush-builtins/Cargo.toml

@@ -134,10 +134,8 @@ cfg-if = "1.0.4"
 chrono = "0.4.44"
 clap = { version = "4.6.0", features = ["derive", "wrap_help"] }
 fancy-regex = "0.18.0"
-futures = "0.3.32"
 itertools = "0.14.0"
 strum = "0.28.0"
-strum_macros = "0.28.0"
 thiserror = "2.0.18"
 tracing = "0.1.44"
 

brush-builtins/src/bind.rs

@@ -461,22 +461,23 @@ fn display_funcs_and_bindings(
     let sorted_funcs = interfaces::InputFunction::iter().sorted_by_key(|f| f.to_string());
 
     for func in sorted_funcs {
-        if let Some(seqs) = sequences_by_func.get(&func) {
-            if reusable {
+        match sequences_by_func.get(&func) {
+            Some(seqs) if reusable => {
                 for seq in seqs {
                     writeln!(context.stdout(), "\"{seq}\": {func}")?;
                 }
-            } else {
+            }
+            Some(seqs) => {
                 writeln!(
                     context.stdout(),
                     "{func} can be found on {}.",
                     seqs.iter().map(|seq| std::format!("\"{seq}\"")).join(", ")
                 )?;
             }
-        } else {
-            if reusable {
+            None if reusable => {
                 writeln!(context.stdout(), "# {func} (not bound)")?;
-            } else {
+            }
+            None => {
                 writeln!(context.stdout(), "{func} is not bound to any keys")?;
             }
         }

brush-builtins/src/command.rs

@@ -27,8 +27,8 @@ pub(crate) struct CommandCommand {
 }
 
 impl CommandCommand {
-    fn command(&self) -> Option<&String> {
-        self.command_and_args.first()
+    fn command(&self) -> Option<&str> {
+        self.command_and_args.first().map(|s| s.as_str())
     }
 }
 
@@ -42,11 +42,9 @@ impl builtins::Command for CommandCommand {
         // Silently exit if no command was provided.
         if let Some(command_name) = self.command() {
             if self.print_description || self.print_verbose_description {
-                if let Some(found_cmd) = Self::try_find_command(
-                    context.shell,
-                    command_name.as_str(),
-                    self.use_default_path,
-                ) {
+                if let Some(found_cmd) =
+                    Self::try_find_command(context.shell, command_name, self.use_default_path)
+                {
                     if self.print_description {
                         writeln!(context.stdout(), "{found_cmd}")?;
                     } else {
@@ -134,7 +132,10 @@ impl CommandCommand {
         use_default_path: bool,
     ) -> Result<ExecutionResult, brush_core::Error> {
         command_name.clone_into(&mut context.command_name);
-        let command_and_args = self.command_and_args.iter().map(|arg| arg.into()).collect();
+        let command_and_args = self
+            .command_and_args
+            .iter()
+            .map(brush_core::CommandArg::from);
 
         let path_dirs = if use_default_path {
             Some(sys::fs::get_default_standard_utils_paths())

brush-builtins/src/complete.rs

@@ -148,42 +148,24 @@ impl CommonCompleteCommandArgs {
     fn resolve_actions(&self) -> Vec<CompleteAction> {
         let mut actions = self.actions.clone();
 
-        if self.action_alias {
-            actions.push(CompleteAction::Alias);
-        }
-        if self.action_builtin {
-            actions.push(CompleteAction::Builtin);
-        }
-        if self.action_command {
-            actions.push(CompleteAction::Command);
-        }
-        if self.action_directory {
-            actions.push(CompleteAction::Directory);
-        }
-        if self.action_exported {
-            actions.push(CompleteAction::Export);
-        }
-        if self.action_file {
-            actions.push(CompleteAction::File);
-        }
-        if self.action_group {
-            actions.push(CompleteAction::Group);
-        }
-        if self.action_job {
-            actions.push(CompleteAction::Job);
-        }
-        if self.action_keyword {
-            actions.push(CompleteAction::Keyword);
-        }
-        if self.action_service {
-            actions.push(CompleteAction::Service);
-        }
-        if self.action_user {
-            actions.push(CompleteAction::User);
-        }
-        if self.action_variable {
-            actions.push(CompleteAction::Variable);
-        }
+        actions.extend(
+            [
+                (self.action_alias, CompleteAction::Alias),
+                (self.action_builtin, CompleteAction::Builtin),
+                (self.action_command, CompleteAction::Command),
+                (self.action_directory, CompleteAction::Directory),
+                (self.action_exported, CompleteAction::Export),
+                (self.action_file, CompleteAction::File),
+                (self.action_group, CompleteAction::Group),
+                (self.action_job, CompleteAction::Job),
+                (self.action_keyword, CompleteAction::Keyword),
+                (self.action_service, CompleteAction::Service),
+                (self.action_user, CompleteAction::User),
+                (self.action_variable, CompleteAction::Variable),
+            ]
+            .into_iter()
+            .filter_map(|(enabled, action)| enabled.then_some(action)),
+        );
 
         actions
     }
@@ -575,7 +557,8 @@ impl builtins::Command for CompOptCommand {
         &self,
         context: brush_core::ExecutionContext<'_, SE>,
     ) -> Result<brush_core::ExecutionResult, Self::Error> {
-        let mut options = HashMap::new();
+        let mut options =
+            HashMap::with_capacity(self.disabled_options.len() + self.enabled_options.len());
         for option in &self.disabled_options {
             options.insert(option.clone(), false);
         }
@@ -637,14 +620,17 @@ impl builtins::Command for CompOptCommand {
 }
 
 impl CompOptCommand {
-    fn set_options_for_spec(spec: &mut Spec, options: &HashMap<CompleteOption, bool>) {
+    fn set_options_for_spec<'a, I>(spec: &mut Spec, options: I)
+    where
+        I: IntoIterator<Item = (&'a CompleteOption, &'a bool)>,
+    {
         Self::set_options(&mut spec.options, options);
     }
 
-    fn set_options(
-        target_options: &mut completion::GenerationOptions,
-        options: &HashMap<CompleteOption, bool>,
-    ) {
+    fn set_options<'a, I>(target_options: &mut completion::GenerationOptions, options: I)
+    where
+        I: IntoIterator<Item = (&'a CompleteOption, &'a bool)>,
+    {
         for (option, value) in options {
             match option {
                 CompleteOption::BashDefault => target_options.bash_default = *value,

brush-builtins/src/history.rs

@@ -1,6 +1,9 @@
 use brush_core::{ExecutionExitCode, ExecutionResult, builtins, error, history};
 use clap::Parser;
-use std::{io::Write, path::PathBuf};
+use std::{
+    io::Write,
+    path::{Path, PathBuf},
+};
 
 /// Query or manipulate the shell's command history.
 // TODO(history): Evaluate which of the options conflict with each other.
@@ -67,7 +70,7 @@ impl builtins::Command for HistoryCommand {
         let stderr = context.stderr();
 
         if let Some(history) = context.shell.history_mut() {
-            self.execute_with_history(history, config, stdout, stderr)
+            self.execute_with_history(history, &config, stdout, stderr)
         } else {
             Err(brush_core::ErrorKind::HistoryNotEnabled.into())
         }
@@ -81,7 +84,7 @@ impl HistoryCommand {
     fn execute_with_history(
         &self,
         history: &mut history::History,
-        config: HistoryConfig,
+        config: &HistoryConfig,
         stdout: impl Write,
         mut stderr: impl Write,
     ) -> Result<ExecutionResult, brush_core::Error> {
@@ -118,8 +121,8 @@ impl HistoryCommand {
 
         if let Some(append_option) = &self.append_session_to_file {
             if let Some(file_path) = get_effective_history_file_path(
-                config.default_history_file_path,
-                append_option.as_ref(),
+                config.default_history_file_path.as_deref(),
+                append_option.as_deref(),
             ) {
                 history.flush(
                     file_path,
@@ -142,8 +145,8 @@ impl HistoryCommand {
 
         if let Some(write_option) = &self.write_session_to_file {
             if let Some(file_path) = get_effective_history_file_path(
-                config.default_history_file_path,
-                write_option.as_ref(),
+                config.default_history_file_path.as_deref(),
+                write_option.as_deref(),
             ) {
                 history.flush(
                     file_path,
@@ -171,7 +174,7 @@ impl HistoryCommand {
             None
         };
 
-        display_history(history, &config, max_entries, stdout, stderr)?;
+        display_history(history, config, max_entries, stdout, stderr)?;
 
         Ok(ExecutionResult::success())
     }
@@ -211,14 +214,11 @@ fn display_history(
     Ok(())
 }
 
-fn get_effective_history_file_path(
-    default_history_file_path: Option<PathBuf>,
-    option: Option<&String>,
-) -> Option<PathBuf> {
-    option.map_or_else(
-        || default_history_file_path,
-        |file_path| Some(PathBuf::from(file_path)),
-    )
+fn get_effective_history_file_path<'a>(
+    default_history_file_path: Option<&'a Path>,
+    option: Option<&'a str>,
+) -> Option<&'a Path> {
+    option.map(Path::new).or(default_history_file_path)
 }
 
 #[cfg(test)]

brush-builtins/src/read.rs

@@ -259,9 +259,7 @@ fn build_variable_fields(
     match input_line {
         Some(line) if skip_ifs_splitting => {
             // With -N, don't split - put entire input in first variable.
-            let mut fields = VecDeque::new();
-            fields.push_back(line.to_string());
-            fields
+            VecDeque::from([line.to_string()])
         }
         Some(line) => split_line_by_ifs(ifs, line, Some(num_variables)),
         None => VecDeque::new(),

brush-builtins/src/trap.rs

@@ -53,7 +53,7 @@ impl builtins::Command for TrapCommand {
         } else {
             let handler = &self.args[0];
 
-            let mut signal_types = vec![];
+            let mut signal_types = Vec::with_capacity(self.args.len() - 1);
             for signal in &self.args[1..] {
                 signal_types.push(signal.parse()?);
             }

brush-core/examples/call-func.rs

@@ -35,7 +35,7 @@ async fn run_func(shell: &mut brush_core::Shell, suppress_stdout: bool) -> Resul
     }
 
     let result = shell
-        .invoke_function("hello", std::iter::once("arg"), &params)
+        .invoke_function("hello", std::iter::once("arg"), params)
         .await?;
 
     eprintln!("[Function invocation result: {result}]");

brush-core/src/builtins.rs

@@ -46,14 +46,16 @@ pub trait Command: clap::Parser {
         if !Self::takes_plus_options() {
             Self::try_parse_from(args)
         } else {
+            let args = args.into_iter();
+
+            let (lower, _) = args.size_hint();
+
             // N.B. clap doesn't support named options like '+x'. To work around this, we
             // establish a pattern of renaming them.
-            let mut updated_args = vec![];
+            let mut updated_args = Vec::with_capacity(lower);
             for arg in args {
                 if let Some(plus_options) = arg.strip_prefix("+") {
-                    for c in plus_options.chars() {
-                        updated_args.push(format!("--+{c}"));
-                    }
+                    updated_args.extend(plus_options.chars().map(|c| format!("--+{c}")));
                 } else {
                     updated_args.push(arg);
                 }

brush-core/src/commands.rs

@@ -324,17 +324,20 @@ impl<'a, SE: extensions::ShellExtensions> SimpleCommand<'a, SE> {
     /// * `params` - The execution parameters for the command.
     /// * `command_name` - The name of the command to execute.
     /// * `args` - The arguments to the command, including the command itself.
-    pub const fn new(
+    pub fn new<I>(
         shell: ShellForCommand<'a, SE>,
         params: ExecutionParameters,
         command_name: String,
-        args: Vec<CommandArg>,
-    ) -> Self {
+        args: I,
+    ) -> Self
+    where
+        I: IntoIterator<Item = CommandArg>,
+    {
         Self {
             shell,
             params,
             command_name,
-            args,
+            args: args.into_iter().collect(),
             use_functions: true,
             path_dirs: None,
             process_group_id: None,