get rid of chunked iterators for facts.

src/prolog/codegen.rs

@@ -194,7 +194,6 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker>
                 self.update_var_count(term_or_cut_ref.post_order_iter());
                 vs.mark_vars_in_chunk(term_or_cut_ref.post_order_iter(),
                                       last_term_arity,
-                                      chunk_num,
                                       term_loc);
             }
         }
@@ -501,9 +500,14 @@ impl<'a, TermMarker: Allocator<'a>> CodeGenerator<'a, TermMarker>
 
     pub fn compile_fact<'b: 'a>(&mut self, term: &'b Term) -> Code
     {
-        let iter = ChunkedIterator::from_fact(term);
+        self.update_var_count(term.post_order_iter());
 
-        self.collect_var_data(iter);
+        let mut vs = VariableFixtures::new();
+        vs.mark_vars_in_chunk(term.post_order_iter(), term.arity(), GenContext::Head);
+
+        vs.populate_restricting_sets();
+
+        self.marker.drain_var_data(vs);
         self.marker.advance(GenContext::Head, term.arity());
 
         let mut code = Vec::new();

src/prolog/fixtures.rs

@@ -174,10 +174,10 @@ impl<'a> VariableFixtures<'a>
     pub fn mark_vars_in_chunk<Iter>(&mut self,
                                     iter: Iter,
                                     last_term_arity: usize,                                    
-                                    chunk_num: usize,
                                     term_loc: GenContext)
         where Iter: Iterator<Item=TermRef<'a>>
     {
+        let chunk_num = term_loc.chunk_num();
         let mut arg_c = 1;
 
         for term_ref in iter {

src/prolog/iterators.rs

@@ -200,18 +200,6 @@ pub struct ChunkedIterator<'a>
 
 impl<'a> ChunkedIterator<'a>
 {
-    pub fn from_fact(term: &'a Term) -> Self
-    {
-        let inner_iter: Box<Iterator<Item=QueryTermRef<'a>>> =
-            Box::new(once(QueryTermRef::Term(term)));
-
-        ChunkedIterator {
-            term_loc: GenContext::Head,
-            iter: inner_iter,
-            deep_cut_encountered: false,
-        }
-    }
-
     pub fn from_term_sequence(terms: &'a [QueryTerm]) -> Self
     {
         let iter = terms.iter().map(|c| c.to_ref());