chore(Turborepo): Scope down opts needed by the visitor, remove run lifetime

crates/turborepo-lib/src/commands/run.rs

@@ -30,7 +30,7 @@ pub async fn run(base: CommandBase, telemetry: CommandEventBuilder) -> Result<i3
 
     let handler = SignalHandler::new(signal);
 
-    let mut run = Run::new(&base);
+    let mut run = Run::new(base);
     debug!("using the experimental rust codepath");
     debug!("configured run struct: {:?}", run);
     let run_fut = run.run(&handler, telemetry);

crates/turborepo-lib/src/run/mod.rs

@@ -61,13 +61,13 @@ use crate::{
 };
 
 #[derive(Debug)]
-pub struct Run<'a> {
-    base: &'a CommandBase,
+pub struct Run {
+    base: CommandBase,
     processes: ProcessManager,
 }
 
-impl<'a> Run<'a> {
-    pub fn new(base: &'a CommandBase) -> Self {
+impl Run {
+    pub fn new(base: CommandBase) -> Self {
         let processes = ProcessManager::new();
         Self { base, processes }
     }
@@ -472,7 +472,7 @@ impl<'a> Run<'a> {
             pkg_dep_graph.clone(),
             runcache,
             run_tracker,
-            &opts,
+            &opts.run_opts,
             package_inputs_hashes,
             &env_at_execution_start,
             &global_hash,
@@ -517,6 +517,7 @@ impl<'a> Run<'a> {
                 global_hash_inputs,
                 &engine,
                 &env_at_execution_start,
+                opts.scope_opts.pkg_inference_root.as_deref(),
             )
             .await?;
 

crates/turborepo-lib/src/task_graph/visitor.rs

@@ -15,7 +15,7 @@ use tokio::{
     sync::{mpsc, oneshot},
 };
 use tracing::{debug, error, Instrument, Span};
-use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf};
+use turbopath::{AbsoluteSystemPath, AbsoluteSystemPathBuf, AnchoredSystemPath};
 use turborepo_ci::github_header_footer;
 use turborepo_env::{EnvironmentVariableMap, ResolvedEnvMode};
 use turborepo_repository::{
@@ -31,7 +31,7 @@ use which::which;
 use crate::{
     cli::EnvMode,
     engine::{Engine, ExecutionOptions, StopExecution},
-    opts::Opts,
+    opts::RunOpts,
     process::{ChildExit, ProcessManager},
     run::{
         global_hash::GlobalHashableInputs,
@@ -52,7 +52,7 @@ pub struct Visitor<'a> {
     global_env: EnvironmentVariableMap,
     global_env_mode: EnvMode,
     manager: ProcessManager,
-    opts: &'a Opts<'a>,
+    run_opts: &'a RunOpts<'a>,
     package_graph: Arc<PackageGraph>,
     repo_root: &'a AbsoluteSystemPath,
     run_cache: Arc<RunCache>,
@@ -92,7 +92,7 @@ impl<'a> Visitor<'a> {
         package_graph: Arc<PackageGraph>,
         run_cache: Arc<RunCache>,
         run_tracker: RunTracker,
-        opts: &'a Opts,
+        run_opts: &'a RunOpts,
         package_inputs_hashes: PackageInputsHashes,
         env_at_execution_start: &'a EnvironmentVariableMap,
         global_hash: &'a str,
@@ -105,19 +105,19 @@ impl<'a> Visitor<'a> {
     ) -> Self {
         let task_hasher = TaskHasher::new(
             package_inputs_hashes,
-            opts,
+            run_opts,
             env_at_execution_start,
             global_hash,
         );
-        let sink = Self::sink(opts, silent);
+        let sink = Self::sink(run_opts, silent);
         let color_cache = ColorSelector::default();
 
         Self {
             color_cache,
             dry: false,
             global_env_mode,
             manager,
-            opts,
+            run_opts,
             package_graph,
             repo_root,
             run_cache,
@@ -135,7 +135,7 @@ impl<'a> Visitor<'a> {
         engine: Arc<Engine>,
         telemetry: &GenericEventBuilder,
     ) -> Result<Vec<TaskError>, Error> {
-        let concurrency = self.opts.run_opts.concurrency as usize;
+        let concurrency = self.run_opts.concurrency as usize;
         let (node_sender, mut node_stream) = mpsc::channel(concurrency);
         let engine_handle = {
             let engine = engine.clone();
@@ -313,11 +313,12 @@ impl<'a> Visitor<'a> {
         global_hash_inputs: GlobalHashableInputs<'_>,
         engine: &Engine,
         env_at_execution_start: &EnvironmentVariableMap,
+        pkg_inference_root: Option<&AnchoredSystemPath>,
     ) -> Result<(), Error> {
         let Self {
             package_graph,
             ui,
-            opts,
+            run_opts,
             repo_root,
             global_env_mode,
             task_hasher,
@@ -333,8 +334,8 @@ impl<'a> Visitor<'a> {
                 &package_graph,
                 ui,
                 repo_root,
-                opts.scope_opts.pkg_inference_root.as_deref(),
-                &opts.run_opts,
+                pkg_inference_root,
+                run_opts,
                 packages,
                 global_hash_summary,
                 global_env_mode,
@@ -345,10 +346,10 @@ impl<'a> Visitor<'a> {
             .await?)
     }
 
-    fn sink(opts: &Opts, silent: bool) -> OutputSink<StdWriter> {
+    fn sink(run_opts: &RunOpts, silent: bool) -> OutputSink<StdWriter> {
         let (out, err) = if silent {
             (std::io::sink().into(), std::io::sink().into())
-        } else if opts.run_opts.should_redirect_stderr_to_stdout() {
+        } else if run_opts.should_redirect_stderr_to_stdout() {
             (std::io::stdout().into(), std::io::stdout().into())
         } else {
             (std::io::stdout().into(), std::io::stderr().into())
@@ -357,7 +358,7 @@ impl<'a> Visitor<'a> {
     }
 
     fn output_client(&self, task_id: &TaskId) -> OutputClient<impl std::io::Write> {
-        let behavior = match self.opts.run_opts.log_order {
+        let behavior = match self.run_opts.log_order {
             crate::opts::ResolvedLogOrder::Stream if self.run_tracker.spaces_enabled() => {
                 turborepo_ui::OutputClientBehavior::InMemoryBuffer
             }
@@ -368,8 +369,8 @@ impl<'a> Visitor<'a> {
         };
 
         let mut logger = self.sink.logger(behavior);
-        if self.opts.run_opts.is_github_actions {
-            let package = if self.opts.run_opts.single_package {
+        if self.run_opts.is_github_actions {
+            let package = if self.run_opts.single_package {
                 None
             } else {
                 Some(task_id.package())
@@ -381,8 +382,8 @@ impl<'a> Visitor<'a> {
     }
 
     fn prefix<'b>(&self, task_id: &'b TaskId) -> Cow<'b, str> {
-        match self.opts.run_opts.log_prefix {
-            crate::opts::ResolvedLogPrefix::Task if self.opts.run_opts.single_package => {
+        match self.run_opts.log_prefix {
+            crate::opts::ResolvedLogPrefix::Task if self.run_opts.single_package => {
                 task_id.task().into()
             }
             crate::opts::ResolvedLogPrefix::Task => {
@@ -394,7 +395,7 @@ impl<'a> Visitor<'a> {
 
     // Task ID as displayed in error messages
     fn display_task_id(&self, task_id: &TaskId) -> String {
-        match self.opts.run_opts.single_package {
+        match self.run_opts.single_package {
             true => task_id.task().to_string(),
             false => task_id.to_string(),
         }
@@ -568,11 +569,11 @@ impl<'a> ExecContextFactory<'a> {
         execution_env: EnvironmentVariableMap,
     ) -> ExecContext {
         let task_id_for_display = self.visitor.display_task_id(&task_id);
-        let pass_through_args = self.visitor.opts.run_opts.args_for_task(&task_id);
+        let pass_through_args = self.visitor.run_opts.args_for_task(&task_id);
         ExecContext {
             engine: self.engine.clone(),
             ui: self.visitor.ui,
-            is_github_actions: self.visitor.opts.run_opts.is_github_actions,
+            is_github_actions: self.visitor.run_opts.is_github_actions,
             pretty_prefix: self
                 .visitor
                 .color_cache
@@ -586,7 +587,7 @@ impl<'a> ExecContextFactory<'a> {
             manager: self.manager.clone(),
             task_hash,
             execution_env,
-            continue_on_error: self.visitor.opts.run_opts.continue_on_error,
+            continue_on_error: self.visitor.run_opts.continue_on_error,
             pass_through_args,
             errors: self.errors.clone(),
         }

crates/turborepo-lib/src/task_hash.rs

@@ -20,7 +20,7 @@ use crate::{
     engine::TaskNode,
     framework::infer_framework,
     hash::{FileHashes, LockFilePackages, TaskHashable, TurboHash},
-    opts::Opts,
+    opts::RunOpts,
     run::task_id::TaskId,
     task_graph::TaskDefinition,
 };
@@ -181,7 +181,7 @@ pub struct TaskHashTrackerState {
 /// Caches package-inputs hashes, and package-task hashes.
 pub struct TaskHasher<'a> {
     hashes: HashMap<TaskId<'static>, String>,
-    opts: &'a Opts<'a>,
+    run_opts: &'a RunOpts<'a>,
     env_at_execution_start: &'a EnvironmentVariableMap,
     global_hash: &'a str,
     task_hash_tracker: TaskHashTracker,
@@ -190,7 +190,7 @@ pub struct TaskHasher<'a> {
 impl<'a> TaskHasher<'a> {
     pub fn new(
         package_inputs_hashes: PackageInputsHashes,
-        opts: &'a Opts,
+        run_opts: &'a RunOpts,
         env_at_execution_start: &'a EnvironmentVariableMap,
         global_hash: &'a str,
     ) -> Self {
@@ -200,7 +200,7 @@ impl<'a> TaskHasher<'a> {
         } = package_inputs_hashes;
         Self {
             hashes,
-            opts,
+            run_opts,
             env_at_execution_start,
             global_hash,
             task_hash_tracker: TaskHashTracker::new(expanded_hashes),
@@ -217,8 +217,8 @@ impl<'a> TaskHasher<'a> {
         dependency_set: HashSet<&TaskNode>,
         telemetry: PackageTaskEventBuilder,
     ) -> Result<String, Error> {
-        let do_framework_inference = self.opts.run_opts.framework_inference;
-        let is_monorepo = !self.opts.run_opts.single_package;
+        let do_framework_inference = self.run_opts.framework_inference;
+        let is_monorepo = !self.run_opts.single_package;
 
         let hash_of_files = self
             .hashes
@@ -327,7 +327,7 @@ impl<'a> TaskHasher<'a> {
             task: task_id.task(),
             outputs,
 
-            pass_through_args: self.opts.run_opts.pass_through_args,
+            pass_through_args: self.run_opts.pass_through_args,
             env: &task_definition.env,
             resolved_env_vars: hashable_env_pairs,
             pass_through_env: task_definition