Move RemoteCopyLibs to test_helpers

Author: jieyouxu

src/bootstrap/src/core/build_steps/test/mod.rs

@@ -13,7 +13,7 @@ use std::{env, fs, iter};
 
 use clap_complete::shells;
 
-use self::test_helpers::{prepare_cargo_test, run_cargo_test};
+use self::test_helpers::{RemoteCopyLibs, prepare_cargo_test, run_cargo_test};
 use crate::core::build_steps::compile::run_cargo;
 use crate::core::build_steps::doc::DocumentationFormat;
 use crate::core::build_steps::llvm::get_llvm_version;
@@ -1723,60 +1723,6 @@ impl Step for Crate {
     }
 }
 
-/// Some test suites are run inside emulators or on remote devices, and most
-/// of our test binaries are linked dynamically which means we need to ship
-/// the standard library and such to the emulator ahead of time. This step
-/// represents this and is a dependency of all test suites.
-///
-/// Most of the time this is a no-op. For some steps such as shipping data to
-/// QEMU we have to build our own tools so we've got conditional dependencies
-/// on those programs as well. Note that the remote test client is built for
-/// the build target (us) and the server is built for the target.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct RemoteCopyLibs {
-    compiler: Compiler,
-    target: TargetSelection,
-}
-
-impl Step for RemoteCopyLibs {
-    type Output = ();
-
-    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
-        run.never()
-    }
-
-    fn run(self, builder: &Builder<'_>) {
-        let compiler = self.compiler;
-        let target = self.target;
-        if !builder.remote_tested(target) {
-            return;
-        }
-
-        builder.ensure(compile::Std::new(compiler, target));
-
-        builder.info(&format!("REMOTE copy libs to emulator ({target})"));
-
-        let server = builder.ensure(tool::RemoteTestServer { compiler, target });
-
-        // Spawn the emulator and wait for it to come online
-        let tool = builder.tool_exe(Tool::RemoteTestClient);
-        let mut cmd = command(&tool);
-        cmd.arg("spawn-emulator").arg(target.triple).arg(&server).arg(builder.tempdir());
-        if let Some(rootfs) = builder.qemu_rootfs(target) {
-            cmd.arg(rootfs);
-        }
-        cmd.run(builder);
-
-        // Push all our dylibs to the emulator
-        for f in t!(builder.sysroot_target_libdir(compiler, target).read_dir()) {
-            let f = t!(f);
-            if helpers::is_dylib(&f.path()) {
-                command(&tool).arg("push").arg(f.path()).run(builder);
-            }
-        }
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Distcheck;
 

src/bootstrap/src/core/build_steps/test/test_helpers.rs

@@ -1,11 +1,12 @@
 use std::env;
 use std::path::PathBuf;
 
-use crate::core::build_steps::tool::Tool;
-use crate::core::builder::{self, Builder, Kind};
+use crate::core::build_steps::compile;
+use crate::core::build_steps::tool::{self, Tool};
+use crate::core::builder::{self, Builder, Compiler, Kind, ShouldRun, Step};
 use crate::core::config::TargetSelection;
-use crate::utils::exec::BootstrapCommand;
-use crate::utils::helpers::{self, dylib_path, dylib_path_var};
+use crate::utils::exec::{BootstrapCommand, command};
+use crate::utils::helpers::{self, dylib_path, dylib_path_var, t};
 use crate::utils::render_tests::add_flags_and_try_run_tests;
 use crate::{DocTests, envify};
 
@@ -122,3 +123,55 @@ pub(super) fn prepare_cargo_test(
 
     cargo
 }
+
+/// Some test suites are run inside emulators or on remote devices, and most of our test binaries
+/// are linked dynamically which means we need to ship the standard library and such to the emulator
+/// ahead of time. This step represents this and is a dependency of all test suites.
+///
+/// Most of the time this is a no-op. For some steps such as shipping data to QEMU we have to build
+/// our own tools so we've got conditional dependencies on those programs as well. Note that the
+/// remote test client is built for the build target (us) and the server is built for the target.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub(super) struct RemoteCopyLibs {
+    pub(super) compiler: Compiler,
+    pub(super) target: TargetSelection,
+}
+
+impl Step for RemoteCopyLibs {
+    type Output = ();
+
+    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_> {
+        run.never()
+    }
+
+    fn run(self, builder: &Builder<'_>) {
+        let compiler = self.compiler;
+        let target = self.target;
+        if !builder.remote_tested(target) {
+            return;
+        }
+
+        builder.ensure(compile::Std::new(compiler, target));
+
+        builder.info(&format!("REMOTE copy libs to emulator ({target})"));
+
+        let server = builder.ensure(tool::RemoteTestServer { compiler, target });
+
+        // Spawn the emulator and wait for it to come online
+        let tool = builder.tool_exe(Tool::RemoteTestClient);
+        let mut cmd = command(&tool);
+        cmd.arg("spawn-emulator").arg(target.triple).arg(&server).arg(builder.tempdir());
+        if let Some(rootfs) = builder.qemu_rootfs(target) {
+            cmd.arg(rootfs);
+        }
+        cmd.run(builder);
+
+        // Push all our dylibs to the emulator
+        for f in t!(builder.sysroot_target_libdir(compiler, target).read_dir()) {
+            let f = t!(f);
+            if helpers::is_dylib(&f.path()) {
+                command(&tool).arg("push").arg(f.path()).run(builder);
+            }
+        }
+    }
+}