From 3b6138eaaad8b0615e3aed726613609b5ccb42e7 Mon Sep 17 00:00:00 2001
From: Mark Thom <markjordanthom@gmail.com>
Date: Tue, 5 Apr 2022 21:02:39 -0600
Subject: [PATCH] limit use of stackless iterator to test suite

---
 src/heap_iter.rs              | 6 +++++-
 src/machine/arithmetic_ops.rs | 4 ++--
 src/machine/gc.rs             | 1 +
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/src/heap_iter.rs b/src/heap_iter.rs
index fdbc6254..21a65dbd 100644
--- a/src/heap_iter.rs
+++ b/src/heap_iter.rs
@@ -1,3 +1,4 @@
+#[cfg(test)]
 pub(crate) use crate::machine::gc::{IteratorUMP, StacklessPreOrderHeapIter};
 use crate::machine::heap::*;
 
@@ -223,6 +224,7 @@ impl<'a> Iterator for StackfulPreOrderHeapIter<'a> {
     }
 }
 
+#[cfg(test)]
 #[inline(always)]
 pub(crate) fn stackless_preorder_iter(
     heap: &mut Vec<HeapCellValue>,
@@ -335,9 +337,11 @@ pub(crate) fn stackful_post_order_iter<'a>(
     PostOrderIterator::new(StackfulPreOrderHeapIter::new(heap, cell))
 }
 
+#[cfg(test)]
 pub(crate) type RightistPostOrderHeapIter<'a> =
     PostOrderIterator<StacklessPreOrderHeapIter<'a, IteratorUMP>>;
 
+#[cfg(test)]
 #[inline]
 pub(crate) fn stackless_post_order_iter<'a>(
     heap: &'a mut Heap,
@@ -440,7 +444,7 @@ mod tests {
             ]
         ));
 
-        for _ in 0..200 { // 000 {
+        for _ in 0..200000 {
             let mut iter = stackless_preorder_iter(&mut wam.machine_st.heap, heap_loc_as_cell!(0));
 
             assert_eq!(
diff --git a/src/machine/arithmetic_ops.rs b/src/machine/arithmetic_ops.rs
index d66fc8e0..01dd9d55 100644
--- a/src/machine/arithmetic_ops.rs
+++ b/src/machine/arithmetic_ops.rs
@@ -1098,7 +1098,7 @@ impl MachineState {
 
     pub(crate) fn arith_eval_by_metacall(&mut self, value: HeapCellValue) -> Result<Number, MachineStub> {
         let stub_gen = || functor_stub(atom!("is"), 2);
-        let mut iter = stackless_post_order_iter(&mut self.heap, value);
+        let mut iter = stackful_post_order_iter(&mut self.heap, value);
 
         while let Some(value) = iter.next() {
             if value.get_forwarding_bit() {
@@ -1125,8 +1125,8 @@ impl MachineState {
             read_heap_cell!(value,
                 (HeapCellValueTag::Atom, (name, arity)) => {
                     if arity == 2 {
-                        let a1 = self.interms.pop().unwrap();
                         let a2 = self.interms.pop().unwrap();
+                        let a1 = self.interms.pop().unwrap();
 
                         match name {
                             atom!("+") => self.interms.push(drop_iter_on_err!(
diff --git a/src/machine/gc.rs b/src/machine/gc.rs
index a56580ad..05bd70d6 100644
--- a/src/machine/gc.rs
+++ b/src/machine/gc.rs
@@ -104,6 +104,7 @@ impl<'a> StacklessPreOrderHeapIter<'a, MarkerUMP> {
 }
 
 impl<'a> StacklessPreOrderHeapIter<'a, IteratorUMP> {
+    #[cfg(test)]
     pub(crate) fn new(heap: &'a mut Vec<HeapCellValue>, cell: HeapCellValue) -> Self {
         let orig_heap_len = heap.len();
         let start = orig_heap_len + 1;
-- 
2.54.0