remove model converter from transformer operators. Rely on reference in context

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/muz_qe/dl_context.cpp

@@ -860,7 +860,7 @@ namespace datalog {
     void context::transform_rules(rule_transformer& transf) {
         SASSERT(m_closed); //we must finish adding rules before we start transforming them
         TRACE("dl", display_rules(tout););
-        if (transf(m_rule_set, m_mc)) {
+        if (transf(m_rule_set)) {
             //we have already ensured the negation is stratified and transformations
             //should not break the stratification
             m_rule_set.ensure_closed();

src/muz_qe/dl_context.h

@@ -319,6 +319,7 @@ namespace datalog {
         void ensure_opened();
 
         model_converter_ref& get_model_converter() { return m_mc; }
+        void add_model_converter(model_converter* mc) { m_mc = concat(m_mc.get(), mc); }
         proof_converter_ref& get_proof_converter() { return m_pc; }
         void add_proof_converter(proof_converter* pc) { m_pc = concat(m_pc.get(), pc); }
 

src/muz_qe/dl_mk_array_blast.cpp

@@ -208,7 +208,7 @@ namespace datalog {
         return true;
     }
     
-    rule_set * mk_array_blast::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_array_blast::operator()(rule_set const & source) {
 
         rule_set* rules = alloc(rule_set, m_ctx);
         rule_set::iterator it = source.begin(), end = source.end();

src/muz_qe/dl_mk_array_blast.h

@@ -54,7 +54,7 @@ namespace datalog {
 
         virtual ~mk_array_blast();
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
     };
 

src/muz_qe/dl_mk_bit_blast.cpp

@@ -255,7 +255,7 @@ namespace datalog {
             m_blaster.updt_params(m_params);
         }
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc) {
+        rule_set * operator()(rule_set const & source) {
             // TODO pc
             if (!m_context.get_params().bit_blast()) {
                 return 0;
@@ -284,7 +284,7 @@ namespace datalog {
                 result->add_rule(m_rules.get(i));
             }
 
-            if (mc) {               
+            if (m_context.get_model_converter()) {               
                 filter_model_converter* fmc = alloc(filter_model_converter, m);
                 bit_blast_model_converter* bvmc = alloc(bit_blast_model_converter, m);
                 func_decl_ref_vector const& old_funcs = m_rewriter.m_cfg.old_funcs();
@@ -293,7 +293,7 @@ namespace datalog {
                     fmc->insert(new_funcs[i]);
                     bvmc->insert(old_funcs[i], new_funcs[i]);
                 }
-                mc = concat(mc.get(), concat(bvmc, fmc));
+                m_context.add_model_converter(concat(bvmc, fmc));
             }
             
             return result;
@@ -308,8 +308,8 @@ namespace datalog {
         dealloc(m_impl);
     }
 
-    rule_set * mk_bit_blast::operator()(rule_set const & source, model_converter_ref& mc) {
-        return (*m_impl)(source, mc);
+    rule_set * mk_bit_blast::operator()(rule_set const & source) {
+        return (*m_impl)(source);
     }        
 
 };

src/muz_qe/dl_mk_bit_blast.h

@@ -44,7 +44,7 @@ namespace datalog {
         mk_bit_blast(context & ctx, unsigned priority = 35000);
         ~mk_bit_blast();
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_coalesce.cpp

@@ -171,7 +171,7 @@ namespace datalog {
         return true;
     }    
         
-    rule_set * mk_coalesce::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_coalesce::operator()(rule_set const & source) {
         rule_set* rules = alloc(rule_set, m_ctx);
         rule_set::decl2rules::iterator it = source.begin_grouped_rules(), end = source.end_grouped_rules();
         for (; it != end; ++it) {

src/muz_qe/dl_mk_coalesce.h

@@ -52,7 +52,7 @@ namespace datalog {
          */
         mk_coalesce(context & ctx);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_coi_filter.cpp

@@ -33,9 +33,7 @@ namespace datalog {
     // -----------------------------------
 
 
-    rule_set * mk_coi_filter::operator()(
-        rule_set const & source,
-        model_converter_ref& mc) 
+    rule_set * mk_coi_filter::operator()(rule_set const & source)
     {
         if (source.get_num_rules()==0) {
             return 0;
@@ -80,7 +78,7 @@ namespace datalog {
             if (interesting_preds.contains(pred)) {
                 res->add_rule(r);
             }
-            else if (mc.get()) {
+            else if (m_context.get_model_converter()) {
                 pruned_preds.insert(pred);
             }
         }
@@ -89,14 +87,14 @@ namespace datalog {
             res = 0;
         }
 
-        if (res && mc) {
+        if (res && m_context.get_model_converter()) {
             decl_set::iterator end = pruned_preds.end();
             decl_set::iterator it = pruned_preds.begin();
             extension_model_converter* mc0 = alloc(extension_model_converter, m);
             for (; it != end; ++it) {
                 mc0->insert(*it, m.mk_true());
             }   
-            mc = concat(mc.get(), mc0);
+            m_context.add_model_converter(mc0);
         }
 
         return res.detach();

src/muz_qe/dl_mk_coi_filter.h

@@ -38,9 +38,7 @@ namespace datalog {
             m(ctx.get_manager()),
             m_context(ctx) {}
 
-
-        rule_set * operator()(rule_set const & source,
-                              model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_explanations.cpp

@@ -174,11 +174,9 @@ namespace datalog {
             }
         }
 
-#if 1
         virtual void deallocate() {
             get_plugin().recycle(this);
         }
-#endif
 
     public:
 
@@ -875,14 +873,12 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_explanations::operator()(rule_set const & source, model_converter_ref& mc) {
-        SASSERT(!mc);
+    rule_set * mk_explanations::operator()(rule_set const & source) {
+
         if(source.get_num_rules()==0) {
             return 0;
         }
-
         m_context.collect_predicates(m_original_preds);
-
         rule_set * res = alloc(rule_set, m_context);
         transform_facts(m_context.get_rel_context().get_rmanager());
         transform_rules(source, *res);

src/muz_qe/dl_mk_explanations.h

@@ -82,7 +82,7 @@ namespace datalog {
             return get_union_decl(m_context);
         }
 
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
         static expr* get_explanation(relation_base const& r);
     };

src/muz_qe/dl_mk_extract_quantifiers.cpp

@@ -355,7 +355,7 @@ namespace datalog {
         m_quantifiers.reset();
     }
     
-    rule_set * mk_extract_quantifiers::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_extract_quantifiers::operator()(rule_set const & source) {
         reset();
         rule_set::iterator it = source.begin(), end = source.end();
         for (; !m_has_quantifiers && it != end; ++it) {

src/muz_qe/dl_mk_extract_quantifiers.h

@@ -77,7 +77,7 @@ namespace datalog {
 
         void set_query(func_decl* q);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
         bool has_quantifiers() { return m_has_quantifiers; }
 

src/muz_qe/dl_mk_filter_rules.cpp

@@ -150,7 +150,7 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_filter_rules::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_filter_rules::operator()(rule_set const & source) {
         // TODO mc, pc
         m_tail2filter.reset();
         m_result           = alloc(rule_set, m_context);

src/muz_qe/dl_mk_filter_rules.h

@@ -72,7 +72,7 @@ namespace datalog {
         /**
            \brief Return a new rule set where only filter rules contain atoms with repeated variables and/or values.
         */
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_interp_tail_simplifier.cpp

@@ -572,7 +572,7 @@ namespace datalog {
         return modified;
     }
 
-    rule_set * mk_interp_tail_simplifier::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_interp_tail_simplifier::operator()(rule_set const & source) {
         if (source.get_num_rules() == 0) {
             return 0;
         }

src/muz_qe/dl_mk_interp_tail_simplifier.h

@@ -93,7 +93,7 @@ namespace datalog {
         */
         bool transform_rule(rule * r, rule_ref& res);
 
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_karr_invariants.cpp

@@ -520,7 +520,7 @@ namespace datalog {
         m_hb.set_cancel(true);
     }
     
-    rule_set * mk_karr_invariants::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_karr_invariants::operator()(rule_set const & source) {
         if (!m_ctx.get_params().karr()) {
             return 0;
         }
@@ -590,7 +590,7 @@ namespace datalog {
         for (; it != end; ++it) {
             update_body(*rules, **it);
         }
-        if (mc) {
+        if (m_ctx.get_model_converter()) {
             add_invariant_model_converter* kmc = alloc(add_invariant_model_converter, m);
             rule_set::decl2rules::iterator git  = source.begin_grouped_rules();
             rule_set::decl2rules::iterator gend = source.end_grouped_rules();
@@ -601,7 +601,7 @@ namespace datalog {
                     kmc->add(p, *M);
                 }
             }
-            mc = concat(mc.get(), kmc);
+            m_ctx.add_model_converter(kmc);
         }
         TRACE("dl", rules->display(tout););
         return rules;

src/muz_qe/dl_mk_karr_invariants.h

@@ -69,7 +69,7 @@ namespace datalog {
 
         virtual void cancel(); 
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
     };
 

src/muz_qe/dl_mk_magic_sets.cpp

@@ -317,8 +317,8 @@ namespace datalog {
         m_rules.push_back(r);
     }
 
-    rule_set * mk_magic_sets::operator()(rule_set const & source, model_converter_ref& mc) {
-        SASSERT(!mc);
+    rule_set * mk_magic_sets::operator()(rule_set const & source) {
+        SASSERT(!m_context.get_model_converter());
         unsigned init_rule_cnt = source.get_num_rules();
         {
             func_decl_set intentional;

src/muz_qe/dl_mk_magic_sets.h

@@ -121,7 +121,7 @@ namespace datalog {
          */
         mk_magic_sets(context & ctx, rule * goal_rule);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_partial_equiv.cpp

@@ -86,7 +86,7 @@ namespace datalog {
     }
 
 
-    rule_set * mk_partial_equivalence_transformer::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_partial_equivalence_transformer::operator()(rule_set const & source) {
         // TODO mc  
 
         if (source.get_num_rules() == 0) {

src/muz_qe/dl_mk_partial_equiv.h

@@ -35,7 +35,7 @@ namespace datalog {
             m(ctx.get_manager()),
             m_context(ctx) {}
 
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
     private:
 

src/muz_qe/dl_mk_rule_inliner.cpp

@@ -241,8 +241,10 @@ namespace datalog {
             return false;
         }
 
-        //these conditions are optional, they avoid possible exponential increase 
-        //in the size of the problem
+        // 
+        // these conditions are optional, they avoid possible exponential increase 
+        // in the size of the problem
+        // 
 
         return 
             //m_head_pred_non_empty_tails_ctr.get(pred)<=1
@@ -837,7 +839,7 @@ namespace datalog {
         return done_something;
     }
 
-    rule_set * mk_rule_inliner::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_rule_inliner::operator()(rule_set const & source) {
 
         bool something_done = false;
         ref<horn_subsume_model_converter> hsmc;        
@@ -854,7 +856,7 @@ namespace datalog {
         }
         
 
-        if (mc) {
+        if (m_context.get_model_converter()) {
             hsmc = alloc(horn_subsume_model_converter, m);
         }
         m_mc = hsmc.get();
@@ -881,9 +883,7 @@ namespace datalog {
             res = 0;
         }
         else {
-            if (mc) {
-                mc = concat(mc.get(), hsmc.get());
-            }
+            m_context.add_model_converter(hsmc.get());
         }
 
         return res.detach();

src/muz_qe/dl_mk_rule_inliner.h

@@ -196,7 +196,7 @@ namespace datalog {
         {}
         virtual ~mk_rule_inliner() { }
 
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_similarity_compressor.cpp

@@ -500,7 +500,7 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_similarity_compressor::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_similarity_compressor::operator()(rule_set const & source) {
         // TODO mc
         m_modified = false;
         unsigned init_rule_cnt = source.get_num_rules();

src/muz_qe/dl_mk_similarity_compressor.h

@@ -69,7 +69,7 @@ namespace datalog {
     public:
         mk_similarity_compressor(context & ctx, unsigned threshold_count);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_simple_joins.cpp

@@ -718,8 +718,7 @@ namespace datalog {
         }
     };
 
-    rule_set * mk_simple_joins::operator()(rule_set const & source, model_converter_ref& mc) {
-        // TODO mc
+    rule_set * mk_simple_joins::operator()(rule_set const & source) {
         rule_set rs_aux_copy(m_context);
         rs_aux_copy.add_rules(source);
         if(!rs_aux_copy.is_closed()) {

src/muz_qe/dl_mk_simple_joins.h

@@ -53,7 +53,7 @@ namespace datalog {
     public:
         mk_simple_joins(context & ctx);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_slice.cpp

@@ -802,7 +802,7 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_slice::operator()(rule_set const & src, model_converter_ref& mc) {        
+    rule_set * mk_slice::operator()(rule_set const & src) {        
         for (unsigned i = 0; i < src.get_num_rules(); ++i) {
             if (src.get_rule(i)->has_quantifiers()) {
                 return 0;
@@ -813,7 +813,7 @@ namespace datalog {
         if (m_ctx.generate_proof_trace()) {
             spc = alloc(slice_proof_converter, m_ctx);        
         }
-        if (mc) {
+        if (m_ctx.get_model_converter()) {
             smc = alloc(slice_model_converter, *this, m);
         }
         m_pc = spc.get();
@@ -836,7 +836,7 @@ namespace datalog {
             }
         }
         m_ctx.add_proof_converter(spc.get());
-        mc = concat(mc.get(), smc.get());
+        m_ctx.add_model_converter(smc.get());
         return result;
     }    
 

src/muz_qe/dl_mk_slice.h

@@ -102,7 +102,7 @@ namespace datalog {
 
         virtual ~mk_slice() { }
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
 
         func_decl* get_predicate(func_decl* p) { func_decl* q = p; m_predicates.find(p, q); return q; }
 

src/muz_qe/dl_mk_subsumption_checker.cpp

@@ -332,7 +332,7 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_subsumption_checker::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_subsumption_checker::operator()(rule_set const & source) {
         // TODO mc
 
         m_have_new_total_rule = false;

src/muz_qe/dl_mk_subsumption_checker.h

@@ -84,7 +84,7 @@ namespace datalog {
             reset_dealloc_values(m_ground_unconditional_rule_heads);
         }
 
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_unbound_compressor.cpp

@@ -334,7 +334,7 @@ namespace datalog {
         }
     }
 
-    rule_set * mk_unbound_compressor::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_unbound_compressor::operator()(rule_set const & source) {
         // TODO mc
         m_modified = false;
 

src/muz_qe/dl_mk_unbound_compressor.h

@@ -82,7 +82,7 @@ namespace datalog {
     public:
         mk_unbound_compressor(context & ctx);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_mk_unfold.cpp

@@ -50,7 +50,7 @@ namespace datalog {
         }
     }
         
-    rule_set * mk_unfold::operator()(rule_set const & source, model_converter_ref& mc) {
+    rule_set * mk_unfold::operator()(rule_set const & source) {
         rule_set* rules = alloc(rule_set, m_ctx);
         rule_set::iterator it = source.begin(), end = source.end();
         for (; it != end; ++it) {

src/muz_qe/dl_mk_unfold.h

@@ -44,7 +44,7 @@ namespace datalog {
          */
         mk_unfold(context & ctx);
         
-        rule_set * operator()(rule_set const & source, model_converter_ref& mc);
+        rule_set * operator()(rule_set const & source);
     };
 
 };

src/muz_qe/dl_rule_transformer.cpp

@@ -73,7 +73,7 @@ namespace datalog {
         m_dirty=true;
     }
 
-    bool rule_transformer::operator()(rule_set & rules, model_converter_ref& mc) {
+    bool rule_transformer::operator()(rule_set & rules) {
         ensure_ordered();
 
         bool modified = false;
@@ -87,7 +87,7 @@ namespace datalog {
         for(; it!=end && !m_cancel; ++it) {
             plugin & p = **it;
 
-            rule_set * new_rules = p(rules, mc);
+            rule_set * new_rules = p(rules);
             if (!new_rules) {
                 continue;
             }

src/muz_qe/dl_rule_transformer.h

@@ -23,7 +23,6 @@ Revision History:
 #include"vector.h"
 #include"dl_rule.h"
 #include"dl_rule_set.h"
-#include"model_converter.h"
 
 namespace datalog {
 
@@ -68,7 +67,7 @@ namespace datalog {
            \brief Transform the rule set using the registered transformation plugins. If the rule 
            set has changed, return true; otherwise return false.
         */
-        bool operator()(rule_set & rules, model_converter_ref& mc);
+        bool operator()(rule_set & rules);
     };
     
     class rule_transformer::plugin {
@@ -104,8 +103,7 @@ namespace datalog {
 
            The caller takes ownership of the returned \c rule_set object.
         */
-        virtual rule_set * operator()(rule_set const & source,
-                                      model_converter_ref& mc) = 0;
+        virtual rule_set * operator()(rule_set const & source) = 0;
 
         virtual void cancel() { m_cancel = true; }
 

src/muz_qe/hilbert_basis.cpp

@@ -997,11 +997,9 @@ void hilbert_basis::select_inequality() {
     unsigned best = m_current_ineq;
     unsigned non_zeros = get_num_nonzeros(m_ineqs[best]);
     unsigned prod      = get_ineq_product(m_ineqs[best]);
-    //numeral  diff      = get_ineq_diff(m_ineqs[best]);
     for (unsigned j = best+1; prod != 0 && j < m_ineqs.size(); ++j) {
         unsigned non_zeros2 = get_num_nonzeros(m_ineqs[j]);
         unsigned prod2 = get_ineq_product(m_ineqs[j]);
-        //numeral diff2  = get_ineq_diff(m_ineqs[j]);
         if (prod2 == 0) {
             prod = prod2;
             non_zeros = non_zeros2;
@@ -1010,7 +1008,6 @@ void hilbert_basis::select_inequality() {
         }
         if (non_zeros2 < non_zeros || (non_zeros2 == non_zeros && prod2 < prod)) {
             prod = prod2;
-            //  diff = diff2;
             non_zeros = non_zeros2;
             best = j;
         }