cleanup after msrv bump

Cargo.lock

@@ -2841,7 +2841,6 @@ dependencies = [
  "to-syn-value_derive",
  "tokio",
  "trycmd",
- "version_check",
  "walkdir",
  "warp",
  "wasm-bindgen",

Cargo.toml

@@ -40,9 +40,7 @@ crypto-full = ["dep:ring"]
 collapsible_match = "allow"
 
 [lints.rust]
-unexpected_cfgs = { level = "deny", check-cfg = [
+unexpected_cfgs = "deny"
-    'cfg(rust_version, values("1.87.0"))',
-] }
 function_casts_as_integer = "deny"
 
 [build-dependencies]
@@ -53,7 +51,6 @@ strum_macros = "0.26"
 syn = { version = "2.0.72", features = ['full', 'visit', 'extra-traits'] }
 to-syn-value = "0.1.1"
 to-syn-value_derive = "0.1.1"
-version_check = "0.9.5"
 walkdir = "2"
 
 [dependencies]

build/main.rs

@@ -45,10 +45,6 @@ fn find_prolog_files(path_prefix: &str, current_dir: &Path) -> Vec<(String, Path
 }
 
 fn main() {
-    if version_check::is_min_version("1.87.0").unwrap_or(false) {
-        println!(r#"cargo:rustc-cfg=rust_version="1.87.0""#);
-    }
-
     let has_rustfmt = Command::new("rustfmt")
         .arg("--version")
         .stdin(Stdio::inherit())

src/machine/system_calls.rs

@@ -8850,13 +8850,7 @@ impl Machine {
             .stderr(stderr);
 
         match command.spawn() {
-            #[cfg_attr(rust_version = "1.87.0", expect(unused_mut))]
+            Ok(child) => {
-            Ok(mut child) => {
-                #[cfg(not(rust_version = "1.87.0"))]
-                {
-                    self.anon_pipe_compat(&mut child, &stdin_args, &stdout_args, &stderr_args)?;
-                }
-
                 let child_process_alloc: TypedArenaPtr<Child> =
                     arena_alloc!(child, &mut self.machine_st.arena);
 
@@ -8879,94 +8873,32 @@ impl Machine {
         }
     }
 
-    #[cfg(not(rust_version = "1.87.0"))]
-    fn anon_pipe_compat(
-        &mut self,
-        child: &mut std::process::Child,
-        stdin_args: &[HeapCellValue],
-        stdout_args: &[HeapCellValue],
-        stderr_args: &[HeapCellValue],
-    ) -> CallResult {
-        if let Some(atom!("pipe")) = stdin_args[0].to_atom() {
-            let writer = child.stdin.take().expect("Should have captured stdin");
-
-            let stream = Stream::from_pipe_writer(writer, &mut self.machine_st.arena);
-
-            self.indices
-                .add_stream(stream, atom!("process_create"), 3)
-                .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
-
-            unify!(self.machine_st, stdin_args[1], HeapCellValue::from(stream));
-        }
-
-        if let Some(atom!("pipe")) = stdout_args[0].to_atom() {
-            let writer = child.stdout.take().expect("Should have captured stdout");
-
-            let stream = Stream::from_pipe_reader(
-                PipeReader(PipeReaderInner::Stdout(writer)),
-                &mut self.machine_st.arena,
-            );
-
-            self.indices
-                .add_stream(stream, atom!("process_create"), 3)
-                .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
-
-            unify!(self.machine_st, stdout_args[1], HeapCellValue::from(stream));
-        }
-
-        if let Some(atom!("pipe")) = stderr_args[0].to_atom() {
-            let writer = child.stderr.take().expect("Should have captured stderr");
-
-            let stream = Stream::from_pipe_reader(
-                PipeReader(PipeReaderInner::Stderr(writer)),
-                &mut self.machine_st.arena,
-            );
-
-            self.indices
-                .add_stream(stream, atom!("process_create"), 3)
-                .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
-
-            unify!(self.machine_st, stderr_args[1], HeapCellValue::from(stream));
-        }
-
-        Ok(())
-    }
-
     fn handle_output_stream(&mut self, args: &[HeapCellValue]) -> Result<Stdio, MachineStub> {
         Ok(match args[0].to_atom() {
             Some(atom!("std")) => Stdio::inherit(),
             Some(atom!("null")) => Stdio::null(),
             Some(atom!("pipe")) => {
-                #[cfg(rust_version = "1.87.0")]
+                let (reader, writer) = match std::io::pipe() {
-                #[allow(clippy::incompatible_msrv)]
+                    Ok(pipe_pair) => pipe_pair,
-                {
+                    Err(_) => {
-                    let (reader, writer) = match std::io::pipe() {
+                        return Err(self.machine_st.open_permission_error(
-                        Ok(pipe_pair) => pipe_pair,
+                            atom!("anonymous_pipe"),
-                        Err(_) => {
+                            atom!("process_create"),
-                            return Err(self.machine_st.open_permission_error(
+                            3,
-                                atom!("anonymous_pipe"),
+                        ));
-                                atom!("process_create"),
+                    }
-                                3,
+                };
-                            ));
-                        }
-                    };
 
-                    let stream = Stream::from_pipe_reader(reader, &mut self.machine_st.arena);
+                let stream = Stream::from_pipe_reader(reader, &mut self.machine_st.arena);
 
-                    self.indices
+                self.indices
-                        .add_stream(stream, atom!("process_create"), 3)
+                    .add_stream(stream, atom!("process_create"), 3)
-                        .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
+                    .map_err(|stub_gen| stub_gen(&mut self.machine_st))?;
 
-                    self.machine_st
+                self.machine_st
-                        .bind(args[1].as_var().unwrap(), stream.into());
+                    .bind(args[1].as_var().unwrap(), stream.into());
 
-                    Stdio::from(writer)
+                Stdio::from(writer)
-                }
-
-                #[cfg(not(rust_version = "1.87.0"))]
-                {
-                    Stdio::piped()
-                }
             }
             Some(atom!("file")) => {
                 let path = self.machine_st.value_to_str_like(args[1]).unwrap();