cleanup

- fix some warnings and mark others as expected
- make use of the msrv bump to 1.93.1 and cleanup compat and workarounds

.github/actions/setup-rust/cleanup.sh

@@ -4,7 +4,7 @@ set -e
 echo Cleanup workspace build artifacts and extra target output
 
 # clean just the direct members of the current workspace, use cargo metadata to generalize to all rust projects
-cargo clean -p `cargo metadata --no-deps --offline --format-version 1 | jq -r '[.workspace_members[]|split(" ")|.[0]]|join(" ")'`
+cargo clean --workspace
 
 # remove directories in /target/ that are not named `debug` or `release`
 before=`du -s target | awk '{print $1}'`

Cargo.toml

@@ -37,13 +37,15 @@ http = ["dep:warp", "dep:reqwest"]
 crypto-inpure = ["dep:ring"]
 crypto-full = ["crypto-inpure"]
 
+[lints.clippy]
+collapsible_match = "allow"
+
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = [
     'cfg(rust_version, values("1.87.0"))',
 ] }
 function_casts_as_integer = "deny"
 
-
 [build-dependencies]
 proc-macro2 = "1.0.86"
 quote = "1.0.36"

src/arena.rs

@@ -13,6 +13,8 @@ use ordered_float::OrderedFloat;
 use std::fmt;
 use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
+use std::io::PipeReader;
+use std::io::PipeWriter;
 use std::mem;
 use std::mem::ManuallyDrop;
 use std::net::TcpListener;
@@ -22,8 +24,6 @@ use std::ptr;
 use std::ptr::addr_of_mut;
 use std::ptr::NonNull;
 
-use crate::machine::streams::{PipeReader, PipeWriter};
-
 macro_rules! arena_alloc {
     ($e:expr, $arena:expr) => {{
         let result = $e;

src/codegen.rs

@@ -145,7 +145,7 @@ impl BranchCodeStack {
                     settings.trust_me()
                 });
 
-                combined_code.extend(code.into_iter());
+                combined_code.extend(code);
             }
         }
 
@@ -1236,7 +1236,7 @@ impl CodeGenerator {
             }
 
             self.skeleton.clauses.push_back(clause_index_info);
-            code.extend(clause_code.into_iter());
+            code.extend(clause_code);
         }
 
         let index_code = if clauses_len > 1 || self.settings.is_extensible {
@@ -1313,7 +1313,7 @@ impl CodeGenerator {
                 }
             }
 
-            code.extend(code_segment.into_iter());
+            code.extend(code_segment);
         }
 
         Ok(code)

src/lib.rs

@@ -54,6 +54,8 @@ pub mod wasm;
 /// The entry point for the Scryer Prolog CLI.
 pub fn run_binary() -> std::process::ExitCode {
     use crate::atom_table::Atom;
+
+    #[cfg(feature = "repl")]
     use crate::machine::INTERRUPT;
 
     #[cfg(feature = "repl")]

src/machine/copier.rs

@@ -247,11 +247,12 @@ impl<T: CopierTarget> CopyTermState<T> {
             self.trail
                 .push((TrailRef::pstr_loc(pstr_loc_idx), old_cell));
 
-            let old_tail_idx = if (pstr_loc + offset + 1) % Heap::heap_cell_alignment() == 0 {
+            let old_tail_idx =
-                cell_index!(pstr_loc + offset) + 2
+                if (pstr_loc + offset + 1).is_multiple_of(Heap::heap_cell_alignment()) {
-            } else {
+                    cell_index!(pstr_loc + offset) + 2
-                cell_index!(pstr_loc + offset) + 1
+                } else {
-            };
+                    cell_index!(pstr_loc + offset) + 1
+                };
 
             let tail_cell = self.target[old_tail_idx];
 

src/machine/disjuncts.rs

@@ -549,7 +549,7 @@ impl VariableClassifier {
 
                             let first_branch_num = Arc::new(self.current_branch_num.split());
                             let branches: Vec<_> = std::iter::once(head)
-                                .chain(unfold_by_str(tail, atom!(";")).into_iter())
+                                .chain(unfold_by_str(tail, atom!(";")))
                                 .collect();
 
                             let mut branch_numbers = vec![first_branch_num];
@@ -571,7 +571,7 @@ impl VariableClassifier {
                                 self.current_branch_num.halve_delta(),
                             )));
 
-                            let iter = branches.into_iter().zip(branch_numbers.into_iter());
+                            let iter = branches.into_iter().zip(branch_numbers);
                             let final_disjunct_loc = state_stack.len();
 
                             for (term, branch_num) in iter.rev() {

src/machine/heap.rs

@@ -577,7 +577,7 @@ impl Heap {
     // takes a heap index, returns a cell index
     #[inline]
     pub const fn pstr_tail_idx(pstr_zero_byte_loc: usize) -> usize {
-        if (pstr_zero_byte_loc + 1) % Heap::heap_cell_alignment() == 0 {
+        if (pstr_zero_byte_loc + 1).is_multiple_of(Heap::heap_cell_alignment()) {
             cell_index!(pstr_zero_byte_loc) + 2
         } else {
             cell_index!(pstr_zero_byte_loc) + 1

src/machine/machine_errors.rs

@@ -937,6 +937,7 @@ impl Permission {
 }
 
 #[derive(Debug, Clone, Copy)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
 pub(crate) enum DomainErrorType {
     IOMode,
     NotLessThanZero,
@@ -987,6 +988,7 @@ impl DomainErrorType {
 
 // from 7.12.2 f) of 13211-1:1995
 #[derive(Debug, Clone, Copy)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
 pub(crate) enum RepFlag {
     Character,
     CharacterCode,
@@ -1178,6 +1180,7 @@ impl MachineState {
 }
 
 #[derive(Debug)]
+#[cfg_attr(not(feature = "ffi"), expect(dead_code))]
 pub enum ExistenceError {
     Module(Atom),
     ModuleSource(ModuleSource),

src/machine/machine_state.rs

@@ -548,8 +548,7 @@ impl MachineState {
             return true;
         }
 
-        // use strict_add once msrv is >= 1.91.0
+        self.cwil.global_count = self.cwil.global_count.strict_add(1);
-        self.cwil.global_count = self.cwil.global_count.checked_add(1).unwrap();
 
         if let Some(&(ref limit, block)) = self.cwil.limits.last() {
             if self.cwil.local_count == *limit {
@@ -651,7 +650,7 @@ impl MachineState {
         mut var_list: Vec<(VarKey, HeapCellValue, usize)>,
         singleton_heap_list: HeapCellValue,
     ) -> CallResult {
-        var_list.sort_by(|(_, _, idx_1), (_, _, idx_2)| idx_1.cmp(idx_2));
+        var_list.sort_by_key(|(_, _, idx_1)| *idx_1);
 
         let singleton_addr = self.registers[3];
         unify_fn!(*self, singleton_heap_list, singleton_addr);
@@ -1128,8 +1127,7 @@ impl CWIL {
     }
 
     pub(crate) fn add_limit(&mut self, mut limit: u128, block: usize) -> u128 {
-        // use strict_add once msrv is >= 1.91.0
+        limit = limit.strict_add(self.local_count);
-        limit = limit.checked_add(self.local_count).unwrap();
 
         match self.limits.last() {
             Some((ref inner_limit, _)) if *inner_limit <= limit => {}

src/machine/stack.rs

@@ -195,8 +195,7 @@ impl Stack {
                 // exposed provenance, we need to expose the provenance here, even though we don't
                 // actually use the value for anything. This is a reminder that `expose_provenance`
                 // isn't just a cast from a pointer to an integer but has actual side effects.
-                // FIXME(msrv) remove the as_ptr() call once MSRV reaches 1.89.0
+                cell_ptr.expose_provenance();
-                cell_ptr.as_ptr().expose_provenance();
 
                 offset += mem::size_of::<HeapCellValue>();
             }
@@ -228,8 +227,7 @@ impl Stack {
                 // exposed provenance, we need to expose the provenance here, even though we don't
                 // actually use the value for anything. This is a reminder that `expose_provenance`
                 // isn't just a cast from a pointer to an integer but has actual side effects.
-                // FIXME(msrv) remove as_ptr() call once msrv reaches 1.89.0
+                cell_ptr.expose_provenance();
-                cell_ptr.as_ptr().expose_provenance();
 
                 offset += mem::size_of::<HeapCellValue>();
             }

src/machine/streams.rs

@@ -23,6 +23,8 @@ use std::fmt::Debug;
 use std::fs::{File, OpenOptions};
 use std::hash::Hash;
 use std::io;
+use std::io::PipeReader;
+use std::io::PipeWriter;
 use std::io::{Cursor, ErrorKind, Read, Seek, SeekFrom, Write};
 use std::mem::ManuallyDrop;
 use std::net::{Shutdown, TcpStream};
@@ -38,9 +40,6 @@ use native_tls::TlsStream;
 #[cfg(feature = "http")]
 use warp::hyper;
 
-mod compat;
-pub use compat::*;
-
 #[derive(Debug, Specifier, Clone, Copy, PartialEq, Eq, Hash)]
 #[bits = 1]
 pub enum StreamType {

src/machine/streams/compat.rs

@@ -1,72 +0,0 @@
-#[cfg(rust_version = "1.87.0")]
-pub use ge_1_87_0::{PipeReader, PipeWriter};
-
-#[cfg(not(rust_version = "1.87.0"))]
-pub use lt_1_87_0::{PipeReader, PipeWriter};
-
-#[cfg(not(rust_version = "1.87.0"))]
-pub(crate) use lt_1_87_0::PipeReaderInner;
-
-#[cfg(not(rust_version = "1.87.0"))]
-mod lt_1_87_0 {
-    use std::process::{ChildStderr, ChildStdout};
-
-    pub type PipeWriter = std::process::ChildStdin;
-
-    #[derive(Debug)]
-    pub struct PipeReader(pub(crate) PipeReaderInner);
-
-    #[derive(Debug)]
-    pub(crate) enum PipeReaderInner {
-        Stdout(ChildStdout),
-        Stderr(ChildStderr),
-    }
-
-    impl std::io::Read for PipeReader {
-        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
-            match &mut self.0 {
-                PipeReaderInner::Stdout(child_stdout) => child_stdout.read(buf),
-                PipeReaderInner::Stderr(child_stderr) => child_stderr.read(buf),
-            }
-        }
-
-        fn read_vectored(
-            &mut self,
-            bufs: &mut [std::io::IoSliceMut<'_>],
-        ) -> std::io::Result<usize> {
-            match &mut self.0 {
-                PipeReaderInner::Stdout(child_stdout) => child_stdout.read_vectored(bufs),
-                PipeReaderInner::Stderr(child_stderr) => child_stderr.read_vectored(bufs),
-            }
-        }
-
-        fn read_to_end(&mut self, buf: &mut Vec<u8>) -> std::io::Result<usize> {
-            match &mut self.0 {
-                PipeReaderInner::Stdout(child_stdout) => child_stdout.read_to_end(buf),
-                PipeReaderInner::Stderr(child_stderr) => child_stderr.read_to_end(buf),
-            }
-        }
-
-        fn read_to_string(&mut self, buf: &mut String) -> std::io::Result<usize> {
-            match &mut self.0 {
-                PipeReaderInner::Stdout(child_stdout) => child_stdout.read_to_string(buf),
-                PipeReaderInner::Stderr(child_stderr) => child_stderr.read_to_string(buf),
-            }
-        }
-
-        fn read_exact(&mut self, buf: &mut [u8]) -> std::io::Result<()> {
-            match &mut self.0 {
-                PipeReaderInner::Stdout(child_stdout) => child_stdout.read_exact(buf),
-                PipeReaderInner::Stderr(child_stderr) => child_stderr.read_exact(buf),
-            }
-        }
-    }
-}
-
-#[cfg(rust_version = "1.87.0")]
-mod ge_1_87_0 {
-    #![allow(clippy::incompatible_msrv)]
-
-    pub type PipeReader = std::io::PipeReader;
-    pub type PipeWriter = std::io::PipeWriter;
-}

src/machine/system_calls.rs

@@ -8950,36 +8950,27 @@ impl Machine {
             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_writer(writer, &mut self.machine_st.arena);
+                let stream = Stream::from_pipe_writer(writer, &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(reader)
+                Stdio::from(reader)
-                }
-
-                #[cfg(not(rust_version = "1.87.0"))]
-                {
-                    Stdio::piped()
-                }
             }
             Some(atom!("file")) => {
                 let path = self.machine_st.value_to_str_like(args[1]).unwrap();
@@ -9613,7 +9604,6 @@ impl Machine {
 
 #[cfg(feature = "crypto-inpure")]
 fn rng() -> &'static dyn SecureRandom {
-    use lazy_static::lazy_static;
     use std::ops::Deref;
 
     static RANDOM: LazyLock<SystemRandom> = LazyLock::new(SystemRandom::new);

tests/scryer/issues.rs

@@ -1,6 +1,6 @@
 use crate::helper::load_module_test;
 use crate::helper::load_module_test_with_input;
-#[cfg(not(target_arch = "wasm32"))]
+#[cfg(all(feature = "http", not(target_arch = "wasm32")))]
 use crate::helper::load_module_test_with_tokio_runtime_and_input;
 use serial_test::serial;
 
@@ -164,8 +164,7 @@ fn issue3262_read_from_stdin_no_newline() {
 }
 
 #[test]
-#[cfg(feature = "http")]
+#[cfg(all(feature = "http", not(target_arch = "wasm32")))]
-#[cfg(not(target_arch = "wasm32"))]
 #[cfg_attr(miri, ignore = "it takes too long to run")]
 fn http_open_hanging() {
     load_module_test_with_tokio_runtime_and_input(