Merge pull request #3320 from Skgland/all-pure-rust

add a feature for enabling all features that don't pull in non pure rust dependencies

.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}'`

.github/workflows/check_features.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -e
+
+echo "Checking all feature at once"
+cargo check -q --all-targets --all-features "$@"
+
+features=$(cargo metadata  --no-deps --format-version  1 | jq -r '.packages[] | select(.name = "scryer-prolog") | .features | keys | join(" ")')
+
+for feature in ${features} ; do
+	echo "Checking feature ${feature} in isolation"
+	cargo check -q --all-targets --no-default-features --features=${feature} "$@"
+done

.github/workflows/ci.yml

@@ -53,10 +53,10 @@ jobs:
       matrix:
         include:
           # operating systems
-          - { os: windows-latest, rust-version: stable,  target: 'x86_64-pc-windows-msvc',   publish: true }
+          - { os: windows-latest, rust-version: stable,  target: 'x86_64-pc-windows-msvc',   publish: true, check-features: true }
-          - { os: macos-latest,   rust-version: stable,  target: 'x86_64-apple-darwin',      publish: true }
+          - { os: macos-latest,   rust-version: stable,  target: 'x86_64-apple-darwin',      publish: true, check-features: true }
           # architectures
-          - { os: ubuntu-22.04,   rust-version: stable,  target: 'x86_64-unknown-linux-gnu', publish: true }
+          - { os: ubuntu-22.04,   rust-version: stable,  target: 'x86_64-unknown-linux-gnu', publish: true, check-features: true }
           - { os: ubuntu-22.04,   rust-version: stable,  target: 'i686-unknown-linux-gnu',   publish: true }
           # FIXME(issue #2138): run wasm tests, failing to run since https://github.com/mthom/scryer-prolog/pull/2137 removed wasm-pack
           - { os: ubuntu-22.04,   rust-version: nightly, target: 'wasm32-unknown-unknown',   publish: true, args: '--no-default-features' , test-args: '--no-run --no-default-features', use_swap: true }
@@ -88,9 +88,14 @@ jobs:
       # Build and test.
       - name: Build library
         run: cargo build --all-targets --target ${{ matrix.target }} ${{ matrix.args }} --verbose
+
       - name: Test
         run: cargo test --target ${{ matrix.target }} ${{ matrix.test-args }} --all
 
+      - name: Check features
+        if: matrix.check-features
+        run: bash ./.github/workflows/check_features.sh --target ${{ matrix.target }}
+
       - name: Check miri
         if: matrix.miri
         run: cargo miri test --target ${{ matrix.target }} ${{ matrix.args }}

Cargo.toml

@@ -17,16 +17,27 @@ rust-version = "1.93.1"
 crate-type = ["cdylib", "rlib"]
 
 [features]
-default = ["ffi", "repl", "hostname", "tls", "http", "crypto-full"]
+default = ["all-simple-cross", "tls", "http"]
+# activates all features that depend on no non pure-rust dependencies
+#
+# currently does not include
+# ffi due to libffi
+# tls, http due to openssl
+# crypto-full due to ring
+all-pure = ["repl", "hostname"]
 # enables all features that are simple to get working for cross-compliation
 # currently all but tls, http as those depend on openssl
-all-simple-cross = ["ffi", "repl", "hostname", "crypto-full"]
+all-simple-cross = ["all-pure", "ffi", "crypto-full"]
 ffi = ["dep:libffi"]
 repl = ["dep:crossterm", "dep:ctrlc", "dep:rustyline"]
 hostname = ["dep:hostname"]
 tls = ["dep:native-tls"]
 http = ["dep:warp", "dep:reqwest"]
-crypto-full = []
+# crypto function that require non pure-rust dependencies
+crypto-full = ["dep:ring"]
+
+[lints.clippy]
+collapsible_match = "allow"
 
 [lints.rust]
 unexpected_cfgs = { level = "deny", check-cfg = [
@@ -34,7 +45,6 @@ unexpected_cfgs = { level = "deny", check-cfg = [
 ] }
 function_casts_as_integer = "deny"
 
-
 [build-dependencies]
 proc-macro2 = "1.0.86"
 quote = "1.0.36"
@@ -73,7 +83,9 @@ ordered-float = "5.0.0"
 phf = { version = "0.11", features = ["macros"] }
 puruspe = "0.4.1"
 rand = "0.8.5"
-ring = { version = "0.17.8", features = ["wasm32_unknown_unknown_js"] }
+ring = { version = "0.17.8", features = [
+    "wasm32_unknown_unknown_js",
+], optional = true }
 ripemd = "0.1.3"
 roxmltree = "0.20.0"
 ryu = "1.0.18"

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,7 +247,8 @@ 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 =
+                if (pstr_loc + offset + 1).is_multiple_of(Heap::heap_cell_alignment()) {
                     cell_index!(pstr_loc + offset) + 2
                 } else {
                     cell_index!(pstr_loc + offset) + 1

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

@@ -53,7 +53,6 @@ use std::mem;
 #[cfg(feature = "http")]
 use std::net::{SocketAddr, ToSocketAddrs};
 use std::net::{TcpListener, TcpStream};
-use std::num::NonZeroU32;
 use std::process;
 use std::process::Child;
 use std::process::Stdio;
@@ -74,11 +73,13 @@ use crossterm::event::{read, Event, KeyCode, KeyEvent, KeyEventKind, KeyModifier
 use crossterm::terminal::{disable_raw_mode, enable_raw_mode};
 
 use blake2::{Blake2b512, Blake2s256};
-use ring::rand::{SecureRandom, SystemRandom};
-use ring::{digest, hkdf, hmac, pbkdf2};
 
 #[cfg(feature = "crypto-full")]
-use ring::aead;
+use ring::{
+    aead, digest, hkdf, hmac, pbkdf2,
+    rand::{SecureRandom, SystemRandom},
+};
+
 use ripemd::{Digest, Ripemd160};
 use sha3::{Sha3_224, Sha3_256, Sha3_384, Sha3_512};
 
@@ -96,8 +97,6 @@ use roxmltree;
 use futures::future;
 #[cfg(feature = "http")]
 use reqwest::Url;
-use tokio::runtime::Handle;
-use tokio::task;
 #[cfg(feature = "http")]
 use warp::hyper::header::{HeaderName, HeaderValue};
 #[cfg(feature = "http")]
@@ -4403,6 +4402,8 @@ impl Machine {
     #[cfg(feature = "http")]
     #[inline(always)]
     pub(crate) fn http_open(&mut self) -> CallResult {
+        use tokio::task;
+
         let address_sink = self.deref_register(1);
         let method = read_heap_cell!(self.deref_register(3),
             (HeapCellValueTag::Atom, (name, arity)) => {
@@ -4466,7 +4467,7 @@ impl Machine {
 
             // do it!
             task::block_in_place(move || {
-                match Handle::current().block_on(req.send()) {
+                match tokio::runtime::Handle::current().block_on(req.send()) {
                     Ok(resp) => {
                         // status code
                         let status = resp.status().as_u16();
@@ -7843,6 +7844,8 @@ impl Machine {
 
     #[inline(always)]
     pub(crate) fn crypto_random_byte(&mut self) {
+        #[cfg(feature = "crypto-full")]
+        {
             let arg = self.machine_st.registers[1];
             let mut bytes: [u8; 1] = [0];
 
@@ -7861,6 +7864,15 @@ impl Machine {
             self.machine_st.unify_fixnum(byte, arg);
         }
 
+        #[cfg(not(feature = "crypto-full"))]
+        {
+            let stub_gen = || functor_stub(atom!("crypto_random_byte"), 1);
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn crypto_data_hash(&mut self) {
         let encoding = cell_as_atom!(self.deref_register(2));
@@ -7990,6 +8002,8 @@ impl Machine {
                 )
             }
             _ => {
+                #[cfg(feature = "crypto-full")]
+                {
                     let ints = digest::digest(
                         match algorithm {
                             atom!("sha256") => &digest::SHA256,
@@ -8014,6 +8028,15 @@ impl Machine {
                         )
                     )
                 }
+                #[cfg(not(feature = "crypto-full"))]
+                {
+                    let stub_gen = || functor_stub(atom!("crypto_data_hash"), 1);
+                    let err = self.machine_st.missing_feature_error(atom!("crypto"));
+                    let exception = self.machine_st.error_form(err, stub_gen());
+                    self.machine_st.throw_exception(exception);
+                    return;
+                }
+            }
         };
 
         unify!(self.machine_st, self.machine_st.registers[3], ints_list);
@@ -8021,11 +8044,13 @@ impl Machine {
 
     #[inline(always)]
     pub(crate) fn crypto_hmac(&mut self) {
+        let stub_gen = || functor_stub(atom!("crypto_data_hash"), 3);
+
+        #[cfg(feature = "crypto-full")]
+        {
             let encoding = cell_as_atom!(self.deref_register(2));
             let data = self.string_encoding_bytes(self.machine_st.registers[1], encoding);
 
-        let stub_gen = || functor_stub(atom!("crypto_data_hash"), 3);
-
             let key = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[3], stub_gen);
@@ -8057,12 +8082,23 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[4], ints_list);
         }
 
+        #[cfg(not(feature = "crypto-full"))]
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn crypto_data_hkdf(&mut self) {
+        let stub1_gen = || functor_stub(atom!("crypto_data_hkdf"), 4);
+
+        #[cfg(feature = "crypto-full")]
+        {
             let encoding = cell_as_atom!(self.deref_register(2));
             let data = self.string_encoding_bytes(self.machine_st.registers[1], encoding);
 
-        let stub1_gen = || functor_stub(atom!("crypto_data_hkdf"), 4);
             let salt = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[3], stub1_gen);
@@ -8129,9 +8165,21 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[7], ints_list);
         }
 
+        #[cfg(not(feature = "crypto-full"))]
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub1_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn crypto_password_hash(&mut self) {
         let stub1_gen = || functor_stub(atom!("crypto_password_hash"), 3);
+
+        #[cfg(feature = "crypto-full")]
+        {
+            use std::num::NonZeroU32;
             let data = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[1], stub1_gen);
@@ -8185,6 +8233,14 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[4], ints_list);
         }
 
+        #[cfg(not(feature = "crypto-full"))]
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub1_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[cfg(feature = "crypto-full")]
     #[inline(always)]
     pub(crate) fn crypto_data_encrypt(&mut self) {
@@ -8304,6 +8360,8 @@ impl Machine {
     #[inline(always)]
     pub(crate) fn crypto_curve_scalar_mult(&mut self) {
         let stub_gen = || functor_stub(atom!("crypto_curve_scalar_mult"), 4);
+
+        {
             let scalar_bytes = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[2], stub_gen);
@@ -8323,9 +8381,18 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[4], uncompressed);
         }
 
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn ed25519_seed_to_public_key(&mut self) {
         let stub_gen = || functor_stub(atom!("ed25519_seed_keypair"), 2);
+
+        {
             let seed_bytes = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[1], stub_gen);
@@ -8344,9 +8411,18 @@ impl Machine {
             );
         }
 
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn ed25519_sign_raw(&mut self) {
         let stub_gen = || functor_stub(atom!("ed25519_sign"), 4);
+
+        {
             let seed_bytes = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[1], stub_gen);
@@ -8371,16 +8447,25 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[4], sig_list);
         }
 
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn ed25519_verify_raw(&mut self) {
-        let key_bytes = self.string_encoding_bytes(self.machine_st.registers[1], atom!("octet"));
+        let stub_gen = || functor_stub(atom!("ed25519_verify"), 4);
+
+        {
+            let key_bytes =
+                self.string_encoding_bytes(self.machine_st.registers[1], atom!("octet"));
             let pkey = ed25519::PublicKey::decode(&key_bytes).unwrap();
 
             let encoding = cell_as_atom!(self.deref_register(3));
             let data = self.string_encoding_bytes(self.machine_st.registers[2], encoding);
 
-        let stub_gen = || functor_stub(atom!("ed25519_verify"), 4);
-
             let signature = self
                 .machine_st
                 .integers_to_bytevec(self.machine_st.registers[4], stub_gen);
@@ -8388,16 +8473,24 @@ impl Machine {
             self.machine_st.fail = !pkey.verify_raw(&signature, &data);
         }
 
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn curve25519_scalar_mult(&mut self) {
-        let stub1_gen = || functor_stub(atom!("curve25519_scalar_mult"), 3);
+        let stub_gen = || functor_stub(atom!("curve25519_scalar_mult"), 3);
+
+        {
             let scalar_bytes = self
                 .machine_st
-            .integers_to_bytevec(self.machine_st.registers[1], stub1_gen);
+                .integers_to_bytevec(self.machine_st.registers[1], stub_gen);
-        let stub2_gen = || functor_stub(atom!("curve25519_scalar_mult"), 3);
             let point_bytes = self
                 .machine_st
-            .integers_to_bytevec(self.machine_st.registers[2], stub2_gen);
+                .integers_to_bytevec(self.machine_st.registers[2], stub_gen);
 
             let result = x25519::x25519(
                 &<[u8; 32]>::try_from(&point_bytes[..]).unwrap(),
@@ -8409,6 +8502,13 @@ impl Machine {
             unify!(self.machine_st, self.machine_st.registers[3], string);
         }
 
+        {
+            let err = self.machine_st.missing_feature_error(atom!("crypto"));
+            let exception = self.machine_st.error_form(err, stub_gen());
+            self.machine_st.throw_exception(exception);
+        }
+    }
+
     #[inline(always)]
     pub(crate) fn first_non_octet(&mut self) {
         let addr = self.deref_register(1);
@@ -8848,9 +8948,6 @@ impl Machine {
             Some(atom!("std")) => Stdio::inherit(),
             Some(atom!("null")) => Stdio::null(),
             Some(atom!("pipe")) => {
-                #[cfg(rust_version = "1.87.0")]
-                #[allow(clippy::incompatible_msrv)]
-                {
                 let (reader, writer) = match std::io::pipe() {
                     Ok(pipe_pair) => pipe_pair,
                     Err(_) => {
@@ -8873,12 +8970,6 @@ impl Machine {
 
                 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();
 
@@ -9509,6 +9600,7 @@ impl Machine {
     }
 }
 
+#[cfg(feature = "crypto-full")]
 fn rng() -> &'static dyn SecureRandom {
     use std::ops::Deref;
 
@@ -9517,8 +9609,10 @@ fn rng() -> &'static dyn SecureRandom {
     RANDOM.deref()
 }
 
+#[cfg(feature = "crypto-full")]
 struct MyKey<T: core::fmt::Debug + PartialEq>(T);
 
+#[cfg(feature = "crypto-full")]
 impl hkdf::KeyType for MyKey<usize> {
     fn len(&self) -> usize {
         self.0

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(