clear rustc warnings (#3051)

diff --git a/src/debray_allocator.rs b/src/debray_allocator.rs
index 53c7f206ddb8337c9424701b1ffffd4036432ba3..7fe37259034e1114ceca393a91527a741298a666 100644 (file)
--- a/src/debray_allocator.rs
+++ b/src/debray_allocator.rs
@@ -133,7 +133,10 @@ impl BranchStack {
     }
 
     #[inline]
-    pub(crate) fn drain_branches(&mut self, depth: usize) -> std::vec::Drain<BranchOccurrences> {
+    pub(crate) fn drain_branches(
+        &mut self,
+        depth: usize,
+    ) -> std::vec::Drain<'_, BranchOccurrences> {
         let start_idx = self.len() - depth;
         self.drain(start_idx..)
     }

diff --git a/src/heap_iter.rs b/src/heap_iter.rs
index a57101b93aae6ed0739b0b85538337d7ca9059f9..365d9ca350eb5787f1fc0063340b851bf002ffca 100644 (file)
--- a/src/heap_iter.rs
+++ b/src/heap_iter.rs
@@ -19,7 +19,7 @@ use std::vec::Vec;
 pub fn eager_stackful_preorder_iter(
     heap: &mut Heap,
     value: HeapCellValue,
-) -> EagerStackfulPreOrderHeapIter {
+) -> EagerStackfulPreOrderHeapIter<'_> {
     EagerStackfulPreOrderHeapIter::new(heap, value)
 }
 
@@ -646,7 +646,7 @@ mod tests {
     pub(crate) fn stackless_preorder_iter(
         heap: &mut Heap,
         start: usize,
-    ) -> StacklessPreOrderHeapIter<IteratorUMP> {
+    ) -> StacklessPreOrderHeapIter<'_, IteratorUMP> {
         StacklessPreOrderHeapIter::<IteratorUMP>::new(heap, start)
     }
 
@@ -654,7 +654,7 @@ mod tests {
     pub(crate) fn stackless_post_order_iter(
         heap: &'_ mut Heap,
         start: usize,
-    ) -> RightistPostOrderHeapIter {
+    ) -> RightistPostOrderHeapIter<'_> {
         PostOrderIterator::new(stackless_preorder_iter(heap, start))
     }
 

diff --git a/src/heap_print.rs b/src/heap_print.rs
index 6c3c2cebb7b8558c943a015054125380359cc0d2..44989fb6356a13df6919caecf123057e190e7449 100644 (file)
--- a/src/heap_print.rs
+++ b/src/heap_print.rs
@@ -233,7 +233,6 @@ enum TokenOrRedirect {
     OpenList(Rc<Cell<(bool, usize)>>),
     CloseList(Rc<Cell<(bool, usize)>>),
     HeadTailSeparator,
-    StackPop,
     CommaSeparatedCharList(CommaSeparatedCharList),
 }
 
@@ -1862,10 +1861,6 @@ impl<'a, Outputter: HCValueOutputter> HCPrinter<'a, Outputter> {
                 TokenOrRedirect::Space => push_char!(self, ' '),
                 TokenOrRedirect::LeftCurly => push_char!(self, '{'),
                 TokenOrRedirect::RightCurly => push_char!(self, '}'),
-                TokenOrRedirect::StackPop => {
-                    self.iter.pop_stack();
-                    self.state_stack.push(TokenOrRedirect::Atom(atom!("...")));
-                }
                 TokenOrRedirect::CommaSeparatedCharList(char_list) => {
                     self.print_comma_separated_char_list(char_list);
                 }

diff --git a/src/iterators.rs b/src/iterators.rs
index 8e2e43ddee8ab7cce0d5d94dc670c750228672bf..e3a2ccbdb2f217055aac2d637c2e647b4daee259 100644 (file)
--- a/src/iterators.rs
+++ b/src/iterators.rs
@@ -305,14 +305,14 @@ impl<'a> Iterator for FactIterator<'a> {
     }
 }
 
-pub(crate) fn post_order_iter(term: &'_ Term) -> QueryIterator {
+pub(crate) fn post_order_iter(term: &Term) -> QueryIterator<'_> {
     QueryIterator::from_term(term)
 }
 
 pub(crate) fn breadth_first_iter(
-    term: &'_ Term,
+    term: &Term,
     iterable_root: RootIterationPolicy,
-) -> FactIterator {
+) -> FactIterator<'_> {
     FactIterator::new(term, iterable_root)
 }
 
@@ -336,7 +336,7 @@ pub(crate) struct ClauseIterator<'a> {
     remaining_chunks_on_stack: usize,
 }
 
-fn state_from_chunked_terms(chunk_vec: &'_ VecDeque<ChunkedTerms>) -> ClauseIteratorState {
+fn state_from_chunked_terms(chunk_vec: &VecDeque<ChunkedTerms>) -> ClauseIteratorState<'_> {
     if chunk_vec.len() == 1 {
         if let Some(ChunkedTerms::Branch(ref branches)) = chunk_vec.front() {
             return ClauseIteratorState::RemainingBranches(branches, 0);

diff --git a/src/machine/copier.rs b/src/machine/copier.rs
index 78658c4a9d67c13fa2b543f3098b067179c8cfc7..110371bc7d005c29cd671f66cdc8a649177d7175 100644 (file)
--- a/src/machine/copier.rs
+++ b/src/machine/copier.rs
@@ -82,7 +82,7 @@ pub trait CopierTarget: IndexMut<usize, Output = HeapCellValue> {
     // returns the tail location of the pstr on success
     fn as_slice_from<'a>(&'a self, from: usize) -> Box<dyn Iterator<Item = u8> + 'a>;
     fn copy_pstr_to_threshold(&mut self, pstr_loc: usize) -> Result<usize, usize>;
-    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter, usize>;
+    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter<'_>, usize>;
     fn copy_slice_to_end(&mut self, bounds: Range<usize>) -> Result<(), usize>;
 }
 

diff --git a/src/machine/disjuncts.rs b/src/machine/disjuncts.rs
index 49cf8c1455b93afa001b4b77561d96d8b6b8006f..4ecac7bca2415e06f42b5f3992f1f6b3b0442f8c 100644 (file)
--- a/src/machine/disjuncts.rs
+++ b/src/machine/disjuncts.rs
@@ -18,7 +18,7 @@ use std::collections::VecDeque;
 use std::hash::{Hash, Hasher};
 use std::ops::{Deref, DerefMut};
 
-#[derive(Debug, Clone)]//, PartialOrd, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone)] //, PartialOrd, PartialEq, Eq, Hash)]
 pub struct BranchNumber {
     branch_num: Rational,
     delta: Rational,

diff --git a/src/machine/heap.rs b/src/machine/heap.rs
index e69050abd0ad6e7bd0ae983d39a34440a084f1eb..c6ca9871868e26887c3e1a63bdbd539405870d4a 100644 (file)
--- a/src/machine/heap.rs
+++ b/src/machine/heap.rs
@@ -94,7 +94,7 @@ pub struct HeapStringScan<'a> {
 }
 
 // The heap_slice should be inside the heap
-unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan {
+unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan<'_> {
     let string_len = heap_slice
         .iter()
         .position(|b| *b == 0u8)
@@ -117,7 +117,7 @@ unsafe fn scan_slice_to_str(heap_slice: &[u8]) -> HeapStringScan {
 
 // Same as scan_slice_to_str but assumes that the slice is from the start of a string.
 // Can be used on strings out of the heap.
-unsafe fn scan_slice_to_str_from_start(heap_slice: &[u8]) -> HeapStringScan {
+unsafe fn scan_slice_to_str_from_start(heap_slice: &[u8]) -> HeapStringScan<'_> {
     let string_len = heap_slice
         .iter()
         .position(|b| *b == 0u8)
@@ -529,7 +529,7 @@ impl<'a> SizedHeap for HeapWriter<'a> {
         self.section.cell_len()
     }
 
-    fn scan_slice_to_str(&self, slice_loc: usize) -> HeapStringScan {
+    fn scan_slice_to_str(&self, slice_loc: usize) -> HeapStringScan<'_> {
         let HeapStringScan { string, tail_idx } = unsafe {
             let slice = std::slice::from_raw_parts(
                 self.section.heap_ptr.byte_add(slice_loc),
@@ -612,7 +612,7 @@ impl Heap {
         }
     }
 
-    pub fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter, usize> {
+    pub fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter<'_>, usize> {
         let section;
         let len = heap_index!(num_cells);
 
@@ -1064,7 +1064,7 @@ impl SizedHeap for Heap {
         self.cell_len()
     }
 
-    fn scan_slice_to_str(&self, slice_loc: usize) -> HeapStringScan {
+    fn scan_slice_to_str(&self, slice_loc: usize) -> HeapStringScan<'_> {
         let HeapStringScan { string, tail_idx } = unsafe {
             let slice = std::slice::from_raw_parts(
                 self.inner.ptr.add(slice_loc),

diff --git a/src/machine/lib_machine/mod.rs b/src/machine/lib_machine/mod.rs
index a1ba3399d756e0dad24c9cbdcdb8774186e0d462..fc0369403de983224d6fa133877e45fb76591419 100644 (file)
--- a/src/machine/lib_machine/mod.rs
+++ b/src/machine/lib_machine/mod.rs
@@ -561,7 +561,7 @@ impl Machine {
     }
 
     /// Runs a query.
-    pub fn run_query(&mut self, query: impl Into<String>) -> QueryState {
+    pub fn run_query(&mut self, query: impl Into<String>) -> QueryState<'_> {
         let mut parser = Parser::new(
             Stream::from_owned_string(query.into(), &mut self.machine_st.arena),
             &mut self.machine_st,

diff --git a/src/machine/loader.rs b/src/machine/loader.rs
index 6efe1984dd509b0defbf0d559f17548b5943cd43..b4d5467607f90a23aa9d34d53ee67d0693d84026 100644 (file)
--- a/src/machine/loader.rs
+++ b/src/machine/loader.rs
@@ -1361,7 +1361,7 @@ impl<'a> MachinePreludeView<'a> {
     pub(super) fn composite_op_dir(
         &self,
         compilation_target: &CompilationTarget,
-    ) -> CompositeOpDir {
+    ) -> CompositeOpDir<'_, '_> {
         match compilation_target {
             CompilationTarget::User => CompositeOpDir::new(&self.indices.op_dir, None),
             CompilationTarget::Module(ref module_name) => {

diff --git a/src/machine/machine_indices.rs b/src/machine/machine_indices.rs
index 8a0b6d4161e3c6e6fc0df0abddbf74a8b94d3f5c..7f7bfe35eb705f55a6574229579aa8afa666a41e 100644 (file)
--- a/src/machine/machine_indices.rs
+++ b/src/machine/machine_indices.rs
@@ -136,7 +136,7 @@ impl IndexPtr {
     }
 }
 
-#[derive(Debug, Clone, Copy)]// , Ord, Hash, PartialOrd, Eq, PartialEq)]
+#[derive(Debug, Clone, Copy)] // , Ord, Hash, PartialOrd, Eq, PartialEq)]
 pub struct CodeIndex(CodeIndexOffset);
 
 #[cfg(target_pointer_width = "32")]

diff --git a/src/machine/machine_state.rs b/src/machine/machine_state.rs
index 7663c95269070715c660b517e8635f8c5e771157..c77110c79ebff81bf9924da016c1484bf56a5170 100644 (file)
--- a/src/machine/machine_state.rs
+++ b/src/machine/machine_state.rs
@@ -352,7 +352,7 @@ impl<'a> CopierTarget for CopyTerm<'a> {
     }
 
     #[inline(always)]
-    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter, usize> {
+    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter<'_>, usize> {
         self.state.heap.reserve(num_cells)
     }
 
@@ -478,7 +478,7 @@ impl<'a> CopierTarget for CopyBallTerm<'a> {
     }
 
     #[inline]
-    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter, usize> {
+    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter<'_>, usize> {
         self.stub.reserve(num_cells)
     }
 

diff --git a/src/machine/mock_wam.rs b/src/machine/mock_wam.rs
index 0fcebd412ad743f89802ce17d76eef3195500a5e..df9dbe75644f92b90da3c19b8e958b8b496617f4 100644 (file)
--- a/src/machine/mock_wam.rs
+++ b/src/machine/mock_wam.rs
@@ -178,7 +178,7 @@ impl<'a> CopierTarget for TermCopyingMockWAM<'a> {
     }
 
     #[inline(always)]
-    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter, usize> {
+    fn reserve(&mut self, num_cells: usize) -> Result<HeapWriter<'_>, usize> {
         self.wam.machine_st.heap.reserve(num_cells)
     }
 

diff --git a/src/machine/mod.rs b/src/machine/mod.rs
index 51ae44e49c076d84c345b3d32d175b7322fe35cb..db6dae7e82eb2a852bb610b5a7c9b88c780ab2ba 100644 (file)
--- a/src/machine/mod.rs
+++ b/src/machine/mod.rs
@@ -220,7 +220,7 @@ pub(crate) fn get_structure_index(value: HeapCellValue) -> Option<CodeIndex> {
 
 impl Machine {
     #[inline]
-    fn prelude_view_and_machine_st(&mut self) -> (MachinePreludeView, &mut MachineState) {
+    fn prelude_view_and_machine_st(&mut self) -> (MachinePreludeView<'_>, &mut MachineState) {
         (
             MachinePreludeView {
                 indices: &mut self.indices,

diff --git a/src/machine/partial_string.rs b/src/machine/partial_string.rs
index ee0c2be9f4e79afab1bd44e4713f48b2dbf003ca..977c421c55d4d89241ae08bf159e2a100bdcc607 100644 (file)
--- a/src/machine/partial_string.rs
+++ b/src/machine/partial_string.rs
@@ -5,8 +5,6 @@ use crate::machine::machine_errors::CycleSearchResult;
 use crate::machine::system_calls::BrentAlgState;
 use crate::types::*;
 
-use std::ops::Deref;
-
 #[derive(Clone, Copy)]
 pub struct HeapPStrIter<'a> {
     pub heap: &'a Heap,
@@ -209,55 +207,6 @@ impl<'a> Iterator for HeapPStrIter<'a> {
     }
 }
 
-pub struct PStrCharsIter<'a> {
-    pub iter: HeapPStrIter<'a>,
-    pub item: Option<PStrIteratee>,
-}
-
-impl<'a> Deref for PStrCharsIter<'a> {
-    type Target = HeapPStrIter<'a>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.iter
-    }
-}
-
-impl<'a> Iterator for PStrCharsIter<'a> {
-    type Item = char;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        while let Some(item) = self.item {
-            match item {
-                PStrIteratee::Char { value, .. } => {
-                    self.item = self.iter.next();
-                    return Some(value);
-                }
-                PStrIteratee::PStrSlice {
-                    slice_loc,
-                    slice_len,
-                } => {
-                    let s = self.iter.heap.slice_to_str(slice_loc, slice_len);
-
-                    match s.chars().next() {
-                        Some(c) => {
-                            self.item = Some(PStrIteratee::PStrSlice {
-                                slice_loc: slice_loc + c.len_utf8(),
-                                slice_len: slice_len - c.len_utf8(),
-                            });
-                            return Some(c);
-                        }
-                        None => {
-                            self.item = self.iter.next();
-                        }
-                    }
-                }
-            }
-        }
-
-        None
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;