Merge pull request #2309 from coasys/library-use-case

Iron-out edge cases for library use-case, adding extensive real-world test assertions

.github/workflows/ci.yml

@@ -21,7 +21,7 @@ jobs:
       - name: Setup Rust
         uses: ./.github/actions/setup-rust
         with:
-          rust-version: nightly
+          rust-version: stable
           targets: x86_64-unknown-linux-gnu
           components: clippy, rustfmt
           cache-context: style
@@ -44,7 +44,8 @@ jobs:
           # architectures
           - { os: ubuntu-22.04,   rust-version: stable,  target: 'x86_64-unknown-linux-gnu', publish: true }
           - { os: ubuntu-22.04,   rust-version: stable,  target: 'i686-unknown-linux-gnu',   publish: true }
-          - { os: ubuntu-22.04,   rust-version: nightly, target: 'wasm32-unknown-unknown',   publish: true, args: '--no-default-features' }
+          # 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' }
           # rust versions
           - { os: ubuntu-22.04,   rust-version: "1.70",  target: 'x86_64-unknown-linux-gnu'}
           - { os: ubuntu-22.04,   rust-version: beta,    target: 'x86_64-unknown-linux-gnu'}
@@ -63,11 +64,9 @@ jobs:
 
       # Build and test.
       - name: Build library
-        continue-on-error: ${{ contains(matrix.target,'wasm32') }} # allow wasm builds to fail tests for now
         run: cargo build --all-targets --target ${{ matrix.target }} ${{ matrix.args }} --verbose
       - name: Test
-        continue-on-error: ${{ contains(matrix.target,'wasm32') }} # allow wasm builds to fail tests for now
-        run: cargo test --target ${{ matrix.target }} ${{ matrix.args }} --all
+        run: cargo test --target ${{ matrix.target }} ${{ matrix.test-args }} --all
 
       # On stable rust builds, build a binary and publish as a github actions
       # artifact. These binaries could be useful for testing the pipeline but
@@ -138,7 +137,7 @@ jobs:
       - name: Setup Rust
         uses: ./.github/actions/setup-rust
         with:
-          rust-version: nightly
+          rust-version: stable
           targets: x86_64-unknown-linux-gnu
           cache-context: report
       - run: |

Cargo.toml

@@ -37,52 +37,55 @@ to-syn-value_derive = "0.1.1"
 walkdir = "2"
 
 [dependencies]
+base64 = "0.12.3"
 bit-set = "0.5.3"
 bitvec = "1"
+blake2 = "0.8.1"
+bytes = "1"
+chrono = "0.4.11"
 cpu-time = "1.0.0"
+crrl = "0.6.0"
+dashu = "0.4.0"
+derive_deref = "1.1.1"
 dirs-next = "2.0.0"
 divrem = "0.1.0"
+futures = "0.3"
 fxhash = "0.2.1"
 git-version = "0.3.4"
 indexmap = "1.0.2"
 lazy_static = "1.4.0"
 lexical = "5.2.2"
 libc = "0.2.62"
+libloading = "0.7"
 modular-bitfield = "0.11.2"
+num-order = { version = "1.2.0" }
 ordered-float = "2.6.0"
 phf = { version = "0.9", features = ["macros"] }
+rand = "0.8.5"
 ref_thread_local = "0.0.0"
+regex = "1.9.1"
+ring = { version = "0.17.5", features = ["wasm32_unknown_unknown_js"] }
 ripemd160 = "0.8.0"
-sha3 = "0.8.2"
-blake2 = "0.8.1"
-crrl = "0.6.0"
-chrono = "0.4.11"
-select = "0.6.0"
 roxmltree = "0.11.0"
-base64 = "0.12.3"
+ryu = "1.0.9"
+select = "0.6.0"
+sha3 = "0.8.2"
 smallvec = "1.8.0"
 static_assertions = "1.1.0"
-ryu = "1.0.9"
-futures = "0.3"
-regex = "1.9.1"
-libloading = "0.7"
-derive_deref = "1.1.1"
-bytes = "1"
-dashu = "0.4.0"
-num-order = { version = "1.2.0" }
-rand = "0.8.5"
-ring = { version = "0.17.5", features = ["wasm32_unknown_unknown_js"] }
+
+serde_json = "1.0.95"
+serde = "1.0.159"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-libffi = { version = "3.2.0", optional = true }
-hostname = { version = "0.3.1", optional = true }
 crossterm = { version = "0.20.0", optional = true }
 ctrlc = { version = "3.2.2", optional = true }
-rustyline = { version = "12.0.0", optional = true }
+hostname = { version = "0.3.1", optional = true }
+libffi = { version = "3.2.0", optional = true }
 native-tls = { version = "0.2.4", optional = true }
-warp = { version = "=0.3.5", features = ["tls"], optional = true }
 reqwest = { version = "0.11.18", optional = true }
+rustyline = { version = "12.0.0", optional = true }
 tokio = { version = "1.28.2", features = ["full"] }
+warp = { version = "=0.3.5", features = ["tls"], optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2.10", features = ["js"] }
@@ -99,19 +102,26 @@ console_error_panic_hook = "0.1"
 wasm-bindgen = "0.2.87"
 wasm-bindgen-futures = "0.4"
 serde-wasm-bindgen = "0.5"
-web-sys = { version = "0.3", features = ["Document", "Window", "Element", "Performance"] }
+web-sys = { version = "0.3", features = [
+    "Document",
+    "Window",
+    "Element",
+    "Performance",
+] }
 js-sys = "0.3"
 
 [dev-dependencies]
-assert_cmd = "1.0.3"
-predicates-core = "1.0.2"
 maplit = "1.0.2"
+predicates-core = "1.0.2"
 serial_test = "2.0.0"
-iai-callgrind = { git = "https://github.com/iai-callgrind/iai-callgrind.git", rev = "c77bc3c83d7f4e976cc42d4597236a8db259e772" }
+
+[target.'cfg(not(all(target_arch = "wasm32", target_os = "unknown")))'.dev-dependencies]
+assert_cmd = "1.0.3"
 criterion = "0.5.1"
+iai-callgrind = { git = "https://github.com/iai-callgrind/iai-callgrind.git", rev = "c77bc3c83d7f4e976cc42d4597236a8db259e772" }
 trycmd = "0.14.19"
 
-[target.'cfg(not(target_os = "windows"))'.dev-dependencies]
+[target.'cfg(not(any(target_os = "windows", all(target_arch = "wasm32", target_os = "unknown"))))'.dev-dependencies]
 pprof = { version = "0.13.0", features = ["criterion", "flamegraph"] }
 
 [patch.crates-io]

benches/run_criterion.rs

@@ -1,10 +1,14 @@
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 #[cfg(not(target_os = "windows"))]
 use pprof::criterion::{Output, PProfProfiler};
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod setup;
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 fn bench_criterion(c: &mut Criterion) {
     for (&name, bench) in setup::prolog_benches().iter() {
         match bench.strategy {
@@ -15,7 +19,7 @@ fn bench_criterion(c: &mut Criterion) {
         };
     }
 }
-
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 #[cfg(not(target_os = "windows"))]
 fn config() -> Criterion {
     Criterion::default()
@@ -28,9 +32,15 @@ fn config() -> Criterion {
     Criterion::default().sample_size(20)
 }
 
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 criterion_group!(
     name = benches;
     config = config();
     targets = bench_criterion
 );
+
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 criterion_main!(benches);
+
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+fn main() {}

benches/run_iai.rs

@@ -1,18 +1,38 @@
-use iai_callgrind::{library_benchmark, library_benchmark_group, main};
-use scryer_prolog::machine::parsed_results::QueryResolution;
-
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 mod setup;
 
-#[library_benchmark]
-#[bench::count_edges(setup::prolog_benches()["count_edges"].setup())]
-#[bench::numlist(setup::prolog_benches()["numlist"].setup())]
-#[bench::csv_codename(setup::prolog_benches()["csv_codename"].setup())]
-fn bench(mut run: impl FnMut() -> QueryResolution) -> QueryResolution {
-    run()
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+mod iai {
+    use iai_callgrind::{library_benchmark, library_benchmark_group, main};
+
+    use scryer_prolog::machine::parsed_results::QueryResolution;
+
+    use super::setup;
+
+    #[library_benchmark]
+    #[bench::count_edges(setup::prolog_benches()["count_edges"].setup())]
+    #[bench::numlist(setup::prolog_benches()["numlist"].setup())]
+    #[bench::csv_codename(setup::prolog_benches()["csv_codename"].setup())]
+    fn bench(mut run: impl FnMut() -> QueryResolution) -> QueryResolution {
+        run()
+    }
+
+    library_benchmark_group!(
+        name = benches;
+        benchmarks = bench
+    );
+
+    main!(library_benchmark_groups = benches);
+
+    pub fn call_main() {
+        main()
+    }
+}
+
+#[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
+fn main() {
+    iai::call_main();
 }
 
-library_benchmark_group!(
-    name = benches;
-    benchmarks = bench
-);
-main!(library_benchmark_groups = benches);
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+fn main() {}

benches/setup.rs

@@ -71,6 +71,7 @@ impl PrologBenchmark {
         machine
     }
 
+    #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
     pub fn setup(&self) -> impl FnMut() -> QueryResolution {
         let mut machine = self.make_machine();
         let query = self.query;

build/instructions_template.rs

@@ -1157,27 +1157,27 @@ fn generate_instruction_preface() -> TokenStream {
         impl Instruction {
             #[inline]
             pub fn registers(&self) -> Vec<RegType> {
-                match self {
-                    &Instruction::GetConstant(_, _, r) => vec![r],
-                    &Instruction::GetList(_, r) => vec![r],
-                    &Instruction::GetPartialString(_, _, r, _) => vec![r],
-                    &Instruction::GetStructure(_, _, _, r) => vec![r],
-                    &Instruction::GetVariable(r, t) => vec![r, temp_v!(t)],
-                    &Instruction::GetValue(r, t) => vec![r, temp_v!(t)],
-                    &Instruction::UnifyLocalValue(r) => vec![r],
-                    &Instruction::UnifyVariable(r) => vec![r],
-                    &Instruction::PutConstant(_, _, r) => vec![r],
-                    &Instruction::PutList(_, r) => vec![r],
-                    &Instruction::PutPartialString(_, _, r, _) => vec![r],
-                    &Instruction::PutStructure(_, _, r) => vec![r],
-                    &Instruction::PutValue(r, t) => vec![r, temp_v!(t)],
-                    &Instruction::PutVariable(r, t) => vec![r, temp_v!(t)],
-                    &Instruction::SetLocalValue(r) => vec![r],
-                    &Instruction::SetVariable(r) => vec![r],
-                    &Instruction::SetValue(r) => vec![r],
-                    &Instruction::GetLevel(r) => vec![r],
-                    &Instruction::GetPrevLevel(r) => vec![r],
-                    &Instruction::GetCutPoint(r) => vec![r],
+                match *self {
+                    Instruction::GetConstant(_, _, r) => vec![r],
+                    Instruction::GetList(_, r) => vec![r],
+                    Instruction::GetPartialString(_, _, r, _) => vec![r],
+                    Instruction::GetStructure(_, _, _, r) => vec![r],
+                    Instruction::GetVariable(r, t) => vec![r, temp_v!(t)],
+                    Instruction::GetValue(r, t) => vec![r, temp_v!(t)],
+                    Instruction::UnifyLocalValue(r) => vec![r],
+                    Instruction::UnifyVariable(r) => vec![r],
+                    Instruction::PutConstant(_, _, r) => vec![r],
+                    Instruction::PutList(_, r) => vec![r],
+                    Instruction::PutPartialString(_, _, r, _) => vec![r],
+                    Instruction::PutStructure(_, _, r) => vec![r],
+                    Instruction::PutValue(r, t) => vec![r, temp_v!(t)],
+                    Instruction::PutVariable(r, t) => vec![r, temp_v!(t)],
+                    Instruction::SetLocalValue(r) => vec![r],
+                    Instruction::SetVariable(r) => vec![r],
+                    Instruction::SetValue(r) => vec![r],
+                    Instruction::GetLevel(r) => vec![r],
+                    Instruction::GetPrevLevel(r) => vec![r],
+                    Instruction::GetCutPoint(r) => vec![r],
                     _ => vec![],
                 }
             }

src/bin/scryer-prolog.rs

@@ -1,11 +1,10 @@
 fn main() -> std::process::ExitCode {
     use scryer_prolog::atom_table::Atom;
     use scryer_prolog::*;
-    use std::sync::atomic::Ordering;
 
     #[cfg(feature = "repl")]
     ctrlc::set_handler(move || {
-        scryer_prolog::machine::INTERRUPT.store(true, Ordering::Relaxed);
+        scryer_prolog::machine::INTERRUPT.store(true, std::sync::atomic::Ordering::Relaxed);
     })
     .unwrap();
 

src/ffi.rs

@@ -27,6 +27,7 @@ use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::error::Error;
 use std::ffi::{c_void, CString};
+use std::ptr::addr_of_mut;
 
 use libffi::low::type_tag::STRUCT;
 use libffi::low::{ffi_abi_FFI_DEFAULT_ABI, ffi_cif, ffi_type, prep_cif, types, CodePtr};
@@ -90,20 +91,20 @@ impl ForeignFunctionTable {
     fn map_type_ffi(&mut self, source: &Atom) -> *mut ffi_type {
         unsafe {
             match source {
-                atom!("sint64") => &mut types::sint64,
-                atom!("sint32") => &mut types::sint32,
-                atom!("sint16") => &mut types::sint16,
-                atom!("sint8") => &mut types::sint8,
-                atom!("uint64") => &mut types::uint64,
-                atom!("uint32") => &mut types::uint32,
-                atom!("uint16") => &mut types::uint16,
-                atom!("uint8") => &mut types::uint8,
-                atom!("bool") => &mut types::sint8,
-                atom!("void") => &mut types::void,
-                atom!("cstr") => &mut types::pointer,
-                atom!("ptr") => &mut types::pointer,
-                atom!("f32") => &mut types::float,
-                atom!("f64") => &mut types::double,
+                atom!("sint64") => addr_of_mut!(types::sint64),
+                atom!("sint32") => addr_of_mut!(types::sint32),
+                atom!("sint16") => addr_of_mut!(types::sint16),
+                atom!("sint8") => addr_of_mut!(types::sint8),
+                atom!("uint64") => addr_of_mut!(types::uint64),
+                atom!("uint32") => addr_of_mut!(types::uint32),
+                atom!("uint16") => addr_of_mut!(types::uint16),
+                atom!("uint8") => addr_of_mut!(types::uint8),
+                atom!("bool") => addr_of_mut!(types::sint8),
+                atom!("void") => addr_of_mut!(types::void),
+                atom!("cstr") => addr_of_mut!(types::pointer),
+                atom!("ptr") => addr_of_mut!(types::pointer),
+                atom!("f32") => addr_of_mut!(types::float),
+                atom!("f64") => addr_of_mut!(types::double),
                 struct_name => match self.structs.get_mut(&*struct_name.as_str()) {
                     Some(ref mut struct_type) => &mut struct_type.ffi_type,
                     None => unreachable!(),
@@ -161,7 +162,7 @@ impl ForeignFunctionTable {
     }
 
     fn build_pointer_args(
-        args: &mut Vec<Value>,
+        args: &mut [Value],
         type_args: &[*mut ffi_type],
         structs_table: &mut HashMap<String, StructImpl>,
     ) -> Result<PointerArgs, FFIError> {

src/heap_print.rs

@@ -1727,7 +1727,7 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                        self.print_stream(stream, max_depth);
                    }
                    (ArenaHeaderTag::TcpListener, listener) => {
-                       self.print_tcp_listener(&*listener, max_depth);
+                       self.print_tcp_listener(&listener, max_depth);
                    }
                    (ArenaHeaderTag::Dropped, _value) => {
                        self.print_impromptu_atom(atom!("$dropped_value"));