re-addition of simplified formulas by generic model converter

Signed-off-by: Miguel Angelo Da Terra Neves <t-mineve@microsoft.com>

src/muz/transforms/dl_mk_coi_filter.cpp

@@ -21,7 +21,7 @@ Author:
 #include "muz/dataflow/dataflow.h"
 #include "muz/dataflow/reachability.h"
 #include "ast/ast_pp.h"
-#include "tactic/extension_model_converter.h"
+#include "tactic/generic_model_converter.h"
 
 namespace datalog {
     rule_set * mk_coi_filter::operator()(rule_set const & source) {
@@ -90,10 +90,10 @@ namespace datalog {
 
         // set to false each unreached predicate 
         if (m_context.get_model_converter()) {
-            extension_model_converter* mc0 = alloc(extension_model_converter, m);
+            generic_model_converter* mc0 = alloc(generic_model_converter, m);
-            for (dataflow_engine<reachability_info>::iterator it = engine.begin(); it != engine.end(); it++) {
+            for (auto const& kv : engine) {
-                if (!it->m_value.is_reachable()) {
+                if (!kv.m_value.is_reachable()) {
-                    mc0->insert(it->m_key, m.mk_false());
+                    mc0->add(kv.m_key, m.mk_false());
                 }
             }
             m_context.add_model_converter(mc0);
@@ -127,7 +127,7 @@ namespace datalog {
         if (res && m_context.get_model_converter()) {
             func_decl_set::iterator end = pruned_preds.end();
             func_decl_set::iterator it = pruned_preds.begin();
-            extension_model_converter* mc0 = alloc(extension_model_converter, m);
+            generic_model_converter* mc0 = alloc(generic_model_converter, m);
             for (; it != end; ++it) {
                 const rule_vector& rules = source.get_predicate_rules(*it);
                 expr_ref_vector fmls(m);
@@ -144,7 +144,7 @@ namespace datalog {
                 }
                 expr_ref fml(m);
                 fml = m.mk_or(fmls.size(), fmls.c_ptr());
-                mc0->insert(*it, fml);
+                mc0->add(*it, fml);
             }
             m_context.add_model_converter(mc0);
         }

src/sat/tactic/goal2sat.cpp

@@ -881,8 +881,9 @@ struct sat2goal::imp {
 
     // Wrapper for sat::model_converter: converts it into an "AST level" model_converter.
     class sat_model_converter : public model_converter {
-        sat::model_converter        m_mc;
+        model_converter_ref          m_cached_mc;
-        expr_ref_vector             m_var2expr;
+        sat::model_converter         m_mc;
+        expr_ref_vector              m_var2expr;
         generic_model_converter_ref  m_fmc; // filter for eliminating fresh variables introduced in the assertion-set --> sat conversion
         
         sat_model_converter(ast_manager & m):
@@ -1025,6 +1026,9 @@ struct sat2goal::imp {
             if (m_fmc) m_fmc->collect(visitor);
         }
 
+        void operator()(expr_ref& formula) override {
+            NOT_IMPLEMENTED_YET();
+        }
     };
 
     typedef ref<sat_model_converter> sat_model_converter_ref;
@@ -1033,7 +1037,6 @@ struct sat2goal::imp {
     expr_ref_vector         m_lit2expr;
     unsigned long long      m_max_memory;
     bool                    m_learned;
-    unsigned                m_glue;
     
     imp(ast_manager & _m, params_ref const & p):m(_m), m_lit2expr(m) {
         updt_params(p);
@@ -1041,7 +1044,6 @@ struct sat2goal::imp {
 
     void updt_params(params_ref const & p) {
         m_learned        = p.get_bool("learned", false);
-        m_glue           = p.get_uint("glue", UINT_MAX);
         m_max_memory     = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
     }
 
@@ -1131,7 +1133,6 @@ struct sat2goal::imp {
             checkpoint();
             lits.reset();
             sat::clause const & c = *cp;
-            unsigned sz = c.size();
             if (asserted || m_learned || c.glue() <= s.get_config().m_gc_small_lbd) {
                 for (sat::literal l : c) {
                     lits.push_back(lit2expr(mc, l));
@@ -1142,8 +1143,7 @@ struct sat2goal::imp {
     }
 
     sat::ba_solver* get_ba_solver(sat::solver const& s) {
-        sat::extension* ext = s.get_extension();
+        return dynamic_cast<sat::ba_solver*>(s.get_extension());
-        return dynamic_cast<sat::ba_solver*>(ext);
     }
 
     void operator()(sat::solver const & s, atom2bool_var const & map, goal & r, model_converter_ref & mc) {
@@ -1229,7 +1229,6 @@ sat2goal::sat2goal():m_imp(0) {
 void sat2goal::collect_param_descrs(param_descrs & r) {
     insert_max_memory(r);
     r.insert("learned", CPK_BOOL, "(default: false) collect also learned clauses.");
-    r.insert("glue", CPK_UINT, "(default: max-int) collect learned clauses with glue level below parameter.");
 }
 
 struct sat2goal::scoped_set_imp {

src/solver/solver.cpp

@@ -185,21 +185,20 @@ bool solver::is_literal(ast_manager& m, expr* e) {
 
 void solver::assert_expr(expr* f) {
     expr_ref fml(f, get_manager());
-    if (mc0()) {
+    model_converter_ref mc = get_model_converter();
-        (*mc0())(fml);        
+    if (mc) {
+        (*mc)(fml);        
     }
     assert_expr_core(fml);    
 }
 
 void solver::assert_expr(expr* f, expr* t) {
-    // let mc0 be the model converter associated with the solver
-    // that converts models to their "real state".
     ast_manager& m = get_manager();
     expr_ref fml(f, m);
     expr_ref a(t, m);
-
+    model_converter_ref mc = get_model_converter();
-    if (mc0()) {
+    if (mc) {
-        (*mc0())(fml);        
+        (*mc)(fml);        
         // (*mc0())(a);        
     }
     assert_expr_core(fml, a);    

src/tactic/CMakeLists.txt

@@ -1,7 +1,6 @@
 z3_add_component(tactic
   SOURCES
     equiv_proof_converter.cpp
-    extension_model_converter.cpp
     generic_model_converter.cpp
     goal.cpp
     goal_num_occurs.cpp

src/tactic/arith/fix_dl_var_tactic.cpp

@@ -23,7 +23,7 @@ Revision History:
 --*/
 #include "tactic/tactical.h"
 #include "ast/rewriter/th_rewriter.h"
-#include "tactic/extension_model_converter.h"
+#include "tactic/generic_model_converter.h"
 #include "ast/arith_decl_plugin.h"
 #include "ast/expr_substitution.h"
 #include "ast/ast_smt2_pp.h"
@@ -270,8 +270,8 @@ class fix_dl_var_tactic : public tactic {
                 m_rw.set_substitution(&subst);
             
                 if (m_produce_models) {
-                    extension_model_converter * _mc = alloc(extension_model_converter, m);
+                    generic_model_converter * _mc = alloc(generic_model_converter, m);
-                    _mc->insert(var->get_decl(), zero);
+                    _mc->add(var, zero);
                     mc = _mc;
                 }
                 

src/tactic/arith/lia2pb_tactic.cpp

@@ -20,7 +20,6 @@ Revision History:
 #include "tactic/arith/bound_manager.h"
 #include "ast/rewriter/th_rewriter.h"
 #include "ast/for_each_expr.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "ast/arith_decl_plugin.h"
 #include "ast/expr_substitution.h"
@@ -224,12 +223,10 @@ class lia2pb_tactic : public tactic {
             if (!check_num_bits())
                 throw tactic_exception("lia2pb failed, number of necessary bits exceeds specified threshold (use option :lia2pb-total-bits to increase threshold)");
             
-            extension_model_converter * mc1 = 0;
+            generic_model_converter    * gmc = 0;
-            generic_model_converter    * mc2 = 0;
             if (m_produce_models) {
-                mc1 = alloc(extension_model_converter, m);
+                gmc = alloc(generic_model_converter, m);
-                mc2 = alloc(generic_model_converter, m);
+                mc  = gmc;
-                mc  = concat(mc2, mc1);
             }
             
             expr_ref zero(m);
@@ -259,7 +256,7 @@ class lia2pb_tactic : public tactic {
                         else
                             def_args.push_back(m_util.mk_mul(m_util.mk_numeral(a, true), x_prime));
                         if (m_produce_models)
-                            mc2->hide(x_prime->get_decl());
+                            gmc->hide(x_prime->get_decl());
                         a *= rational(2);
                     }
                     SASSERT(def_args.size() > 1);
@@ -273,7 +270,7 @@ class lia2pb_tactic : public tactic {
                     TRACE("lia2pb", tout << mk_ismt2_pp(x, m) << " -> " << dep << "\n";);
                     subst.insert(x, def, 0, dep);
                     if (m_produce_models) {
-                        mc1->insert(to_app(x)->get_decl(), def);
+                        gmc->add(x, def);
                     }
                 }
             }

src/tactic/arith/nla2bv_tactic.cpp

@@ -26,7 +26,6 @@ Notes:
 #include "util/optional.h"
 #include "tactic/arith/bv2int_rewriter.h"
 #include "tactic/arith/bv2real_rewriter.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "tactic/arith/bound_manager.h"
 #include "util/obj_pair_hashtable.h"
@@ -98,10 +97,9 @@ class nla2bv_tactic : public tactic {
             reduce_bv2int(g);
             reduce_bv2real(g);
             TRACE("nla2bv", g.display(tout << "after reduce\n"););
-            extension_model_converter * evc = alloc(extension_model_converter, m_manager);
+            mc = m_fmc.get();
-            mc = concat(m_fmc.get(), evc);
             for (unsigned i = 0; i < m_vars.size(); ++i) {
-                evc->insert(m_vars[i].get(), m_defs[i].get());
+                m_fmc->add(m_vars[i].get(), m_defs[i].get());
             }
             for (unsigned i = 0; i < m_bv2real.num_aux_decls(); ++i) {
                 m_fmc->hide(m_bv2real.get_aux_decl(i));

src/tactic/arith/normalize_bounds_tactic.cpp

@@ -21,7 +21,6 @@ Revision History:
 #include "tactic/tactical.h"
 #include "tactic/arith/bound_manager.h"
 #include "ast/rewriter/th_rewriter.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "ast/arith_decl_plugin.h"
 #include "ast/expr_substitution.h"
@@ -98,12 +97,10 @@ class normalize_bounds_tactic : public tactic {
                 return;
             }
             
-            extension_model_converter * mc1 = 0;
+            generic_model_converter   * gmc  = 0;
-            generic_model_converter   * mc2  = 0;
             if (produce_models) {
-                mc1 = alloc(extension_model_converter, m);
+                gmc = alloc(generic_model_converter, m);
-                mc2 = alloc(generic_model_converter, m);
+                mc  = gmc;
-                mc  = concat(mc2, mc1);
             }
             
             unsigned num_norm_bounds = 0;
@@ -120,8 +117,8 @@ class normalize_bounds_tactic : public tactic {
                     expr * def = m_util.mk_add(x_prime, m_util.mk_numeral(val, s));
                     subst.insert(x, def);
                     if (produce_models) {
-                        mc1->insert(to_app(x)->get_decl(), def);
+                        gmc->add(to_app(x)->get_decl(), def);
-                        mc2->hide(x_prime->get_decl());
+                        gmc->hide(x_prime->get_decl());
                     }
                 }
             }

src/tactic/arith/purify_arith_tactic.cpp

@@ -28,7 +28,6 @@ Revision History:
 #include "tactic/core/simplify_tactic.h"
 #include "ast/rewriter/th_rewriter.h"
 #include "tactic/generic_model_converter.h"
-#include "tactic/extension_model_converter.h"
 #include "ast/ast_smt2_pp.h"
 #include "ast/rewriter/expr_replacer.h"
 
@@ -776,11 +775,11 @@ struct purify_arith_proc {
             }
         }
         if (produce_models && !m_sin_cos.empty()) {
-            extension_model_converter* emc = alloc(extension_model_converter, m());
+            generic_model_converter* emc = alloc(generic_model_converter, m());
             mc = concat(mc.get(), emc);
             obj_map<app, std::pair<expr*,expr*> >::iterator it = m_sin_cos.begin(), end = m_sin_cos.end();
             for (; it != end; ++it) {
-                emc->insert(it->m_key->get_decl(), 
+                emc->add(it->m_key->get_decl(), 
                             m().mk_ite(u().mk_ge(it->m_value.first, mk_real_zero()), u().mk_acos(it->m_value.second), 
                                        u().mk_add(u().mk_acos(u().mk_uminus(it->m_value.second)), u().mk_pi())));
             }

src/tactic/arith/recover_01_tactic.cpp

@@ -32,7 +32,6 @@ Revision History:
 --*/
 #include "tactic/tactical.h"
 #include "ast/rewriter/th_rewriter.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "ast/arith_decl_plugin.h"
 #include "ast/expr_substitution.h"
@@ -112,8 +111,7 @@ class recover_01_tactic : public tactic {
         }
         
         // temporary fields used by operator() and process
-        extension_model_converter * mc1;
+        generic_model_converter *   gmc;
-        generic_model_converter *    mc2;
         expr_substitution *         subst;
         goal_ref                    new_goal;
         obj_map<expr, expr *>       bool2int;
@@ -205,8 +203,8 @@ class recover_01_tactic : public tactic {
                 expr * bool_def = m.mk_eq(var, m_util.mk_numeral(rational(1), true));
                 subst->insert(atom, bool_def);
                 if (m_produce_models) {
-                    mc2->hide(to_app(var)->get_decl());
+                    gmc->hide(var);
-                    mc1->insert(to_app(atom)->get_decl(), bool_def);
+                    gmc->add(to_app(atom)->get_decl(), bool_def);
                 }
                 m.inc_ref(atom);
                 m.inc_ref(var);
@@ -288,7 +286,7 @@ class recover_01_tactic : public tactic {
             TRACE("recover_01", tout << x->get_name() << " --> " << mk_ismt2_pp(x_def, m) << "\n";);
             subst->insert(m.mk_const(x), x_def);
             if (m_produce_models) {
-                mc1->insert(x, x_def);
+                gmc->add(x, x_def);
             }
             return true;
         }
@@ -328,9 +326,8 @@ class recover_01_tactic : public tactic {
             }
             
             if (m_produce_models) {
-                mc1 = alloc(extension_model_converter, m);
+                gmc = alloc(generic_model_converter, m);
-                mc2 = alloc(generic_model_converter, m);
+                mc  = gmc;
-                mc  = concat(mc2, mc1);
             }
             
             dec_ref_key_values(m, bool2int);

src/tactic/bv/bit_blaster_model_converter.cpp

@@ -21,6 +21,7 @@ Notes:
 #include "tactic/model_converter.h"
 #include "ast/bv_decl_plugin.h"
 #include "ast/ast_smt2_pp.h"
+#include "ast/ast_util.h"
 
 /**
    If TO_BOOL == true, then bit-vectors of size n were blasted into n-tuples of Booleans.
@@ -171,7 +172,7 @@ struct bit_blaster_model_converter : public model_converter {
         return result;
     }
 
-    virtual void operator()(model_ref & md, unsigned goal_idx) {
+    void operator()(model_ref & md, unsigned goal_idx) override {
         SASSERT(goal_idx == 0);
         model * new_model = alloc(model, m());
         obj_hashtable<func_decl> bits;
@@ -181,11 +182,29 @@ struct bit_blaster_model_converter : public model_converter {
         md = new_model;
     }
 
-    virtual void operator()(model_ref & md) {
+    void operator()(model_ref & md) override {
         operator()(md, 0);
     }
+
+    /**
+       \brief simplisic expansion operator for formulas.
+       It just adds back bit-vector definitions to the formula whether they are used or not.
+
+     */
+    void operator()(expr_ref& fml) override {
+        unsigned sz = m_vars.size();
+        if (sz == 0) return;
+        expr_ref_vector fmls(m());
+        fmls.push_back(fml);
+        for (unsigned i = 0; i < sz; i++) {
+            fmls.push_back(m().mk_eq(m().mk_const(m_vars.get(i)), m_bits.get(i)));
+        }        
+        m_vars.reset();
+        m_bits.reset();
+        fml = mk_and(fmls);
+    }
     
-    virtual void display(std::ostream & out) {
+    void display(std::ostream & out) override {
         unsigned sz = m_vars.size();
         for (unsigned i = 0; i < sz; i++) {
             display_add(out, m(), m_vars.get(i), m_bits.get(i));
@@ -196,7 +215,7 @@ protected:
     bit_blaster_model_converter(ast_manager & m):m_vars(m), m_bits(m) { }
 public:
 
-    virtual model_converter * translate(ast_translation & translator) {
+    model_converter * translate(ast_translation & translator) override {
         bit_blaster_model_converter * res = alloc(bit_blaster_model_converter, translator.to());
         for (func_decl * v : m_vars) 
             res->m_vars.push_back(translator(v));
@@ -207,11 +226,11 @@ public:
 };
 
 model_converter * mk_bit_blaster_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bits) {
-    return alloc(bit_blaster_model_converter<true>, m, const2bits);
+    return const2bits.empty() ? nullptr : alloc(bit_blaster_model_converter<true>, m, const2bits);
 }
 
 model_converter * mk_bv1_blaster_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bits) {
-    return alloc(bit_blaster_model_converter<false>, m, const2bits);
+    return const2bits.empty() ? nullptr : alloc(bit_blaster_model_converter<false>, m, const2bits);
 }
 
 

src/tactic/bv/bv_size_reduction_tactic.cpp

@@ -24,7 +24,6 @@ Notes:
 #include "tactic/tactical.h"
 #include "ast/bv_decl_plugin.h"
 #include "ast/rewriter/expr_replacer.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "ast/ast_smt2_pp.h"
 
@@ -51,7 +50,7 @@ tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p) {
 
 struct bv_size_reduction_tactic::imp {
     typedef rational numeral;
-    typedef extension_model_converter bv_size_reduction_mc;
+    typedef generic_model_converter bv_size_reduction_mc;
     
     ast_manager &             m;
     bv_util                   m_util;
@@ -267,7 +266,7 @@ struct bv_size_reduction_tactic::imp {
                             if (m_produce_models) {
                                 if (!m_mc) 
                                     m_mc = alloc(bv_size_reduction_mc, m);
-                                m_mc->insert(v->get_decl(), new_def);
+                                m_mc->add(v, new_def);
                                 if (!m_fmc && new_const) 
                                     m_fmc = alloc(generic_model_converter, m);
                                 if (new_const) 

src/tactic/bv/bvarray2uf_rewriter.cpp

@@ -37,7 +37,6 @@ bvarray2uf_rewriter_cfg::bvarray2uf_rewriter_cfg(ast_manager & m, params_ref con
     m_bindings(m),
     m_bv_util(m),
     m_array_util(m),
-    m_emc(0),
     m_fmc(0),
     extra_assertions(m) {
     updt_params(p);
@@ -115,9 +114,8 @@ func_decl_ref bvarray2uf_rewriter_cfg::mk_uf_for_array(expr * e) {
             bv_f = m_manager.mk_fresh_func_decl("f_t", "", 1, &domain, range);
             TRACE("bvarray2uf_rw", tout << "for " << mk_ismt2_pp(e, m_manager) << " new func_decl is " << mk_ismt2_pp(bv_f, m_manager) << std::endl; );
             if (is_uninterp_const(e)) {
-                if (m_emc)
+                if (m_fmc)
-                    m_emc->insert(to_app(e)->get_decl(),
+                    m_fmc->add(e, m_array_util.mk_as_array(bv_f));
-                                  m_array_util.mk_as_array(bv_f));
             }
             else if (m_fmc)
                 m_fmc->hide(bv_f);
@@ -191,9 +189,8 @@ br_status bvarray2uf_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr
             bv_f = m_manager.mk_fresh_func_decl("f_t", "", 1, &domain, range);
             TRACE("bvarray2uf_rw", tout << mk_ismt2_pp(e, m_manager) << " -> " << bv_f->get_name() << std::endl; );
             if (is_uninterp_const(e)) {
-                if (m_emc)
+                if (m_fmc)
-                    m_emc->insert(e->get_decl(),
+                    m_fmc->add(e, m_array_util.mk_as_array(bv_f));
-                                  m_array_util.mk_as_array(bv_f));
             }
             else if (m_fmc)
                 m_fmc->hide(bv_f);

src/tactic/bv/bvarray2uf_rewriter.h

@@ -21,7 +21,6 @@ Notes:
 #define BVARRAY2UF_REWRITER_H_
 
 #include "ast/rewriter/rewriter.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 
 class bvarray2uf_rewriter_cfg : public default_rewriter_cfg {
@@ -30,7 +29,6 @@ class bvarray2uf_rewriter_cfg : public default_rewriter_cfg {
     sort_ref_vector     m_bindings;
     bv_util             m_bv_util;
     array_util          m_array_util;
-    extension_model_converter * m_emc;
     generic_model_converter * m_fmc;
 
     obj_map<expr, func_decl*> m_arrays_fs;
@@ -59,7 +57,7 @@ public:
 
     expr_ref_vector extra_assertions;
 
-    void set_mcs(extension_model_converter * emc, generic_model_converter * fmc) { m_emc = emc; m_fmc = fmc; }
+    void set_mcs(generic_model_converter * fmc) { m_fmc = fmc; }
 
 protected:
     sort * get_index_sort(expr * e);
@@ -79,7 +77,7 @@ struct bvarray2uf_rewriter : public rewriter_tpl<bvarray2uf_rewriter_cfg> {
         m_cfg(m, p) {
     }
 
-    void set_mcs(extension_model_converter * emc, generic_model_converter * fmc) { m_cfg.set_mcs(emc, fmc); }
+    void set_mcs(generic_model_converter * fmc) { m_cfg.set_mcs(fmc); }
 };
 
 #endif

src/tactic/bv/bvarray2uf_tactic.cpp

@@ -20,7 +20,6 @@ Notes:
 #include "tactic/tactical.h"
 #include "ast/bv_decl_plugin.h"
 #include "ast/rewriter/expr_replacer.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "ast/ast_smt2_pp.h"
 
@@ -68,10 +67,9 @@ class bvarray2uf_tactic : public tactic {
             m_produce_models = g->models_enabled();
 
             if (m_produce_models) {
-                extension_model_converter * emc = alloc(extension_model_converter, m_manager);
                 generic_model_converter * fmc = alloc(generic_model_converter, m_manager);
-                mc = concat(emc, fmc);
+                mc = fmc;
-                m_rw.set_mcs(emc, fmc);
+                m_rw.set_mcs(fmc);
             }
 
 

src/tactic/bv/dt2bv_tactic.cpp

@@ -26,7 +26,6 @@ Revision History:
 #include "ast/bv_decl_plugin.h"
 #include "ast/rewriter/rewriter_def.h"
 #include "tactic/generic_model_converter.h"
-#include "tactic/extension_model_converter.h"
 #include "ast/rewriter/var_subst.h"
 #include "ast/ast_util.h"
 #include "ast/rewriter/enum2bv_rewriter.h"
@@ -134,7 +133,6 @@ public:
         for (sort* s : m_non_fd_sorts) 
             m_fd_sorts.remove(s);
         if (!m_fd_sorts.empty()) {
-            ref<extension_model_converter> ext = alloc(extension_model_converter, m);
             ref<generic_model_converter> filter = alloc(generic_model_converter, m);
             enum2bv_rewriter rw(m, m_params);
             rw.set_is_fd(&m_is_fd);            
@@ -155,9 +153,9 @@ public:
             for (auto const& kv : rw.enum2bv()) 
                 filter->hide(kv.m_value);
             for (auto const& kv : rw.enum2def()) 
-                ext->insert(kv.m_key, kv.m_value);
+                filter->add(kv.m_key, kv.m_value);
             
-            mc = concat(filter.get(), ext.get());
+            mc = filter.get();
             report_tactic_progress(":fd-num-translated", rw.num_translated());
         }
         g->inc_depth();

src/tactic/core/reduce_args_tactic.cpp

@@ -22,7 +22,6 @@ Notes:
 #include "ast/has_free_vars.h"
 #include "util/map.h"
 #include "ast/rewriter/rewriter_def.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 
 /**
@@ -394,13 +393,10 @@ struct reduce_args_tactic::imp {
         ptr_buffer<expr> new_args;
         var_ref_vector   new_vars(m_manager);
         ptr_buffer<expr> new_eqs;
-        extension_model_converter * e_mc = alloc(extension_model_converter, m_manager);
         generic_model_converter * f_mc    = alloc(generic_model_converter, m_manager);
-        decl2arg2func_map::iterator it   = decl2arg2funcs.begin();
+        for (auto const& kv : decl2arg2funcs) {
-        decl2arg2func_map::iterator end  = decl2arg2funcs.end();
+            func_decl * f  = kv.m_key;
-        for (; it != end; ++it) {
+            arg2func * map = kv.m_value;
-            func_decl * f  = it->m_key;
-            arg2func * map = it->m_value;
             expr * def     = 0;
             SASSERT(decl2args.contains(f));
             bit_vector & bv = decl2args.find(f);
@@ -438,9 +434,9 @@ struct reduce_args_tactic::imp {
                 }
             }
             SASSERT(def);
-            e_mc->insert(f, def);
+            f_mc->add(f, def);
         }
-        return concat(f_mc, e_mc);
+        return f_mc;
     }
 
     void operator()(goal & g, model_converter_ref & mc) {

src/tactic/core/solve_eqs_tactic.cpp

@@ -18,7 +18,7 @@ Revision History:
 --*/
 #include "tactic/tactical.h"
 #include "ast/rewriter/expr_replacer.h"
-#include "tactic/extension_model_converter.h"
+#include "tactic/generic_model_converter.h"
 #include "ast/occurs.h"
 #include "util/cooperate.h"
 #include "tactic/goal_shared_occs.h"
@@ -26,7 +26,7 @@ Revision History:
 
 class solve_eqs_tactic : public tactic {
     struct imp {
-        typedef extension_model_converter gmc;
+        typedef generic_model_converter gmc;
         
         ast_manager &                 m_manager;
         expr_replacer *               m_r;
@@ -509,10 +509,8 @@ class solve_eqs_tactic : public tactic {
             expr_ref new_def(m());
             proof_ref new_pr(m());
             expr_dependency_ref new_dep(m());
-            unsigned size = m_ordered_vars.size();
+            for (app * v : m_ordered_vars) {
-            for (unsigned idx = 0; idx < size; idx++) {
                 checkpoint();
-                expr * v   = m_ordered_vars[idx];
                 expr * def = 0;
                 proof * pr = 0;
                 expr_dependency * dep = 0;
@@ -609,16 +607,13 @@ class solve_eqs_tactic : public tactic {
             if (m_produce_models) {
                 if (mc.get() == 0)
                     mc = alloc(gmc, m());
-                ptr_vector<app>::iterator it  = m_ordered_vars.begin();
+                for (app * v : m_ordered_vars) {
-                ptr_vector<app>::iterator end = m_ordered_vars.end();
-                for (; it != end; ++it) {
-                    app * v    = *it;
                     expr * def = 0;
                     proof * pr;
                     expr_dependency * dep;
                     m_norm_subst->find(v, def, pr, dep);
                     SASSERT(def != 0);
-                    static_cast<gmc*>(mc.get())->insert(v->get_decl(), def);
+                    static_cast<gmc*>(mc.get())->add(v, def);
                 }
             }
         }

src/tactic/extension_model_converter.cpp

@@ -1,94 +0,0 @@
-/*++
-Copyright (c) 2011 Microsoft Corporation
-
-Module Name:
-
-    extension_model_converter.cpp
-
-Abstract:
-
-Model converter that introduces eliminated variables in a model.
-
-Author:
-
-    Leonardo (leonardo) 2011-10-21
-
-Notes:
-
---*/
-#include "ast/ast_pp.h"
-#include "ast/ast_smt2_pp.h"
-#include "model/model_evaluator.h"
-#include "model/model_v2_pp.h"
-#include "tactic/extension_model_converter.h"
-
-extension_model_converter::~extension_model_converter() {
-}
-
-#ifdef _TRACE
-static void display_decls_info(std::ostream & out, model_ref & md) {
-    ast_manager & m = md->get_manager();
-    unsigned sz = md->get_num_decls();
-    for (unsigned i = 0; i < sz; i++) {
-        func_decl * d = md->get_decl(i);
-        out << d->get_name();
-        out << " (";
-        for (unsigned j = 0; j < d->get_arity(); j++)
-            out << mk_pp(d->get_domain(j), m);
-        out << mk_pp(d->get_range(), m);
-        out << ") ";
-        if (d->get_info())
-            out << *(d->get_info());
-        out << " :id " << d->get_id() << "\n";
-    }
-}
-#endif
-
-void extension_model_converter::operator()(model_ref & md, unsigned goal_idx) {
-    SASSERT(goal_idx == 0);
-    TRACE("extension_mc", model_v2_pp(tout, *md); display_decls_info(tout, md););
-    model_evaluator ev(*(md.get()));
-    ev.set_model_completion(true);
-    ev.set_expand_array_equalities(false);
-    expr_ref val(m());
-    unsigned i = m_vars.size();
-    while (i > 0) {
-        --i;
-        expr * def = m_defs.get(i);
-        ev(def, val);
-        TRACE("extension_mc", tout << m_vars.get(i)->get_name() << " ->\n" << mk_ismt2_pp(def, m()) << "\n==>\n" << mk_ismt2_pp(val, m()) << "\n";);
-        func_decl * f  = m_vars.get(i);
-        unsigned arity = f->get_arity();
-        if (arity == 0) {
-            md->register_decl(f, val);
-        }
-        else {
-            func_interp * new_fi = alloc(func_interp, m(), arity);
-            new_fi->set_else(val);
-            md->register_decl(f, new_fi);
-        }
-    }
-    TRACE("extension_mc", model_v2_pp(tout, *md); display_decls_info(tout, md););
-}
-
-void extension_model_converter::insert(func_decl * v, expr * def) {
-    m_vars.push_back(v);
-    m_defs.push_back(def);    
-}
-
-
-void extension_model_converter::display(std::ostream & out) {
-    for (unsigned i = 0; i < m_vars.size(); i++) {
-        display_add(out, m(), m_vars.get(i), m_defs.get(i));
-    }
-}
-
-model_converter * extension_model_converter::translate(ast_translation & translator) {
-    extension_model_converter * res = alloc(extension_model_converter, translator.to());
-    for (func_decl* v : m_vars)
-        res->m_vars.push_back(translator(v));
-    for (expr* d : m_defs) 
-        res->m_defs.push_back(translator(d));
-    return res;
-}
-

src/tactic/extension_model_converter.h

@@ -1,48 +0,0 @@
-/*++
-Copyright (c) 2011 Microsoft Corporation
-
-Module Name:
-
-    extension_model_converter.h
-
-Abstract:
-
-    Model converter that introduces new interpretations into a model.
-    It used to be called elim_var_model_converter
-
-    TBD: special case of generic_model_converter
-
-Author:
-
-    Leonardo (leonardo) 2011-10-21
-
-Notes:
-
---*/
-#ifndef EXTENSION_MODEL_CONVERTER_H_
-#define EXTENSION_MODEL_CONVERTER_H_
-
-#include "ast/ast.h"
-#include "tactic/model_converter.h"
-
-class extension_model_converter : public model_converter {
-    func_decl_ref_vector  m_vars;
-    expr_ref_vector       m_defs;
-public:
-    extension_model_converter(ast_manager & m): m_vars(m), m_defs(m) {
-    }
-
-    virtual ~extension_model_converter();
-
-    ast_manager & m() const { return m_vars.get_manager(); }
-
-    virtual void operator()(model_ref & md, unsigned goal_idx);
-
-    virtual void display(std::ostream & out);
-
-    // register a variable that was eliminated
-    void insert(func_decl * v, expr * def);
-
-    virtual model_converter * translate(ast_translation & translator);
-};
-#endif

src/tactic/generic_model_converter.cpp

@@ -18,6 +18,7 @@ Notes:
 
 --*/
 #include "ast/ast_pp.h"
+#include "ast/for_each_expr.h"
 #include "tactic/generic_model_converter.h"
 #include "model/model_v2_pp.h"
 #include "model/model_evaluator.h"
@@ -27,67 +28,95 @@ void generic_model_converter::operator()(model_ref & md, unsigned goal_idx) {
     std::cout << "model converter\n";
     TRACE("model_converter", tout << "before generic_model_converter\n"; model_v2_pp(tout, *md); display(tout););
     model_evaluator ev(*(md.get()));
-    ev.set_model_completion(false);
+    ev.set_model_completion(true);
     ev.set_expand_array_equalities(false);
     expr_ref val(m);
     unsigned arity;
-    for (unsigned i = m_entries.size(); i-- > 0; ) {
+    for (unsigned i = m_hide_entries.size(); i-- > 0; ) {
-        entry const& e = m_entries[i];
+        entry const& e = m_hide_entries[i];
-        switch (e.m_instruction) {
+        std::cout << "hide " << e.m_f << "\n";
-        case HIDE:
+        md->unregister_decl(e.m_f);
-            std::cout << "hide " << e.m_f << "\n";
+    }
-            md->unregister_decl(e.m_f);
+    for (unsigned i = m_add_entries.size(); i-- > 0; ) {
-            break;
+        entry const& e = m_add_entries[i];
-        case ADD:
+        ev(e.m_def, val);
-            ev(e.m_def, val);
+        std::cout << e.m_f << " " << e.m_def << " " << val << "\n";
-            std::cout << e.m_f << " " << e.m_def << " " << val << "\n";
+        TRACE("model_converter", tout << e.m_f->get_name() << " ->\n" << e.m_def << "\n==>\n" << val << "\n";);
-            TRACE("model_converter", tout << e.m_f->get_name() << " ->\n" << e.m_def << "\n==>\n" << val << "\n";);
+        arity = e.m_f->get_arity();
-            arity = e.m_f->get_arity();
+        if (arity == 0) {
-            if (arity == 0) {
+            md->register_decl(e.m_f, val);
-                md->register_decl(e.m_f, val);
+        }
-            }
+        else {
-            else {
+            func_interp * new_fi = alloc(func_interp, m, arity);
-                func_interp * new_fi = alloc(func_interp, m, arity);
+            new_fi->set_else(val);
-                new_fi->set_else(val);
+            md->register_decl(e.m_f, new_fi);
-                md->register_decl(e.m_f, new_fi);
-            }
-            break;
         }
     }
     TRACE("model_converter", tout << "after generic_model_converter\n"; model_v2_pp(tout, *md););
 }
 
 void generic_model_converter::display(std::ostream & out) {
-    for (entry const& e : m_entries) {
+    for (entry const& e : m_hide_entries) {
-        switch (e.m_instruction) {
+        display_del(out, e.m_f);
-        case HIDE:
+    }
-            display_del(out, e.m_f);
+    for (entry const& e : m_add_entries) {
-            break;
+        display_del(out, e.m_f);
-        case ADD:
-            display_add(out, m, e.m_f, e.m_def);
-            break;
-        }
     }
 }
 
 model_converter * generic_model_converter::translate(ast_translation & translator) {
     ast_manager& to = translator.to();
     generic_model_converter * res = alloc(generic_model_converter, to);
-    for (entry const& e : m_entries) 
+    for (entry const& e : m_hide_entries) {
-        res->m_entries.push_back(entry(translator(e.m_f.get()), translator(e.m_def.get()), to, e.m_instruction));
+        res->m_hide_entries.push_back(entry(translator(e.m_f.get()), translator(e.m_def.get()), to, e.m_instruction));
+    }
+    for (entry const& e : m_add_entries) {
+        res->m_add_entries.push_back(entry(translator(e.m_f.get()), translator(e.m_def.get()), to, e.m_instruction));
+    }
     return res;
 }
 
 void generic_model_converter::collect(ast_pp_util& visitor) { 
     m_env = &visitor.env(); 
-    for (entry const& e : m_entries) {
+    for (entry const& e : m_hide_entries) {
+        visitor.coll.visit_func(e.m_f);
+    }
+    for (entry const& e : m_add_entries) {
         visitor.coll.visit_func(e.m_f);
         if (e.m_def) visitor.coll.visit(e.m_def);
     }
 }
 
+struct min_app_idx_proc {
+    unsigned m_min;
+    obj_map<func_decl, unsigned>& m_idxs;
+    min_app_idx_proc(obj_map<func_decl, unsigned>& idxs) : m_min(UINT_MAX), m_idxs(idxs) {}
+    void operator()(app * n) {
+        unsigned idx;
+        if (m_idxs.find(n->get_decl(), idx)) {
+            m_min = std::min(m_min, idx);
+        }
+    }
+    void operator()(var * n) {}
+    void operator()(quantifier * n) {}
+};
+
 void generic_model_converter::operator()(expr_ref& fml) {
-    // TODO: traverse expression and retrieve minimum trail index
+    min_app_idx_proc min_proc(m_first_idx);
-    // TODO: add func = expr starting at that index, removing from table if index is the same
+    for_each_expr(min_proc, fml);
-    NOT_IMPLEMENTED_YET();
+    unsigned min_idx = min_proc.m_min;
+    for (unsigned i = m_add_entries.size(); i-- > min_idx;) {
+        entry const& e = m_add_entries[i];
+        m_add_entries.pop_back();
+        unsigned arity = e.m_f->get_arity();
+        if (arity == 0) {
+            fml = m.mk_and(fml, m.mk_eq(m.mk_const(e.m_f), e.m_def));
+        }
+        else {
+            NOT_IMPLEMENTED_YET();
+        }
+        if (m_first_idx[e.m_f] == i) {
+            m_first_idx.remove(e.m_f);
+        }
+    }
 }

src/tactic/generic_model_converter.h

@@ -34,9 +34,9 @@ class generic_model_converter : public model_converter {
     ast_manager& m;
     vector<entry> m_add_entries;
     vector<entry> m_hide_entries;
-    obj_map<func_decl_ref, unsigned> m_first_idx;
+    obj_map<func_decl, unsigned> m_first_idx;
 public:
-    generic_model_converter(ast_manager & m): m(m) {}
+    generic_model_converter(ast_manager & m) : m(m) {}
     
     virtual ~generic_model_converter() { }
     
@@ -44,7 +44,13 @@ public:
 
     void hide(func_decl * f) { m_hide_entries.push_back(entry(f, 0, m, HIDE)); }
 
-    void add(func_decl * d, expr* e) { m_add_entries.push_back(entry(d, e, m, ADD)); }
+    void add(func_decl * d, expr* e) {
+        struct entry et(d, e, m, ADD);
+        m_first_idx.insert_if_not_there(et.m_f, m_add_entries.size());
+        m_add_entries.push_back(et);
+    }
+
+    void add(expr * d, expr* e) { SASSERT(is_app(d) && to_app(d)->get_num_args() == 0); add(to_app(d)->get_decl(), e); }
     
     virtual void operator()(model_ref & md, unsigned goal_idx);
 

src/tactic/horn_subsume_model_converter.cpp

@@ -170,6 +170,10 @@ void horn_subsume_model_converter::add_default_false_interpretation(expr* e, mod
 }
 
 
+void horn_subsume_model_converter::operator()(expr_ref& fml) {
+    NOT_IMPLEMENTED_YET();
+}
+
 void horn_subsume_model_converter::operator()(model_ref& mr) {
 
     func_decl_ref pred(m);
@@ -190,11 +194,11 @@ void horn_subsume_model_converter::operator()(model_ref& mr) {
         add_default_false_interpretation(body, mr);
         SASSERT(m.is_bool(body));
                 
-        TRACE("mc", tout << "eval: " << h->get_name() << "\n" << mk_pp(body, m) << "\n";);
+        TRACE("mc", tout << "eval: " << h->get_name() << "\n" << body << "\n";);
         expr_ref tmp(body);
         mr->eval(tmp, body);
         
-        TRACE("mc", tout << "to:\n" << mk_pp(body, m) << "\n";);
+        TRACE("mc", tout << "to:\n" << body << "\n";);
                 
         if (arity == 0) {
             expr* e = mr->get_const_interp(h);

src/tactic/horn_subsume_model_converter.h

@@ -58,9 +58,8 @@ class horn_subsume_model_converter : public model_converter {
 
 public:
 
- horn_subsume_model_converter(ast_manager& m): 
+    horn_subsume_model_converter(ast_manager& m): 
-    m(m), m_funcs(m), m_bodies(m), m_rewrite(m),
+        m(m), m_funcs(m), m_bodies(m), m_rewrite(m), m_delay_head(m), m_delay_body(m) {}
-        m_delay_head(m), m_delay_body(m) {}
 
     bool mk_horn(expr* clause, func_decl_ref& pred, expr_ref& body);
 
@@ -72,13 +71,15 @@ public:
 
     void insert(func_decl* p, expr* body) { m_funcs.push_back(p); m_bodies.push_back(body); }
     
-    virtual void operator()(model_ref& _m);
+    void operator()(model_ref& _m) override;
 
-    virtual model_converter * translate(ast_translation & translator);
+    void operator()(expr_ref& fml) override;
+
+    model_converter * translate(ast_translation & translator) override;
 
     ast_manager& get_manager() { return m; }
 
-    virtual void display(std::ostream & out) {}
+    void display(std::ostream & out) override {}
 };
 
 #endif

src/tactic/model_converter.cpp

@@ -58,28 +58,33 @@ public:
         VERIFY(m_c1 && m_c2);
     }
 
-    virtual void operator()(model_ref & m) {
+    void operator()(model_ref & m) override {
         this->m_c2->operator()(m);
         this->m_c1->operator()(m);
     }
 
-    virtual void operator()(model_ref & m, unsigned goal_idx) {
+    void operator()(expr_ref & fml) override {
+        this->m_c1->operator()(fml);
+        this->m_c2->operator()(fml);
+    }
+    
+    void operator()(model_ref & m, unsigned goal_idx) override {
         this->m_c2->operator()(m, goal_idx);
         this->m_c1->operator()(m, 0);
     }
 
-    virtual void operator()(labels_vec & r, unsigned goal_idx) {
+    void operator()(labels_vec & r, unsigned goal_idx) override {
         this->m_c2->operator()(r, goal_idx);
         this->m_c1->operator()(r, 0);
     }
   
-    virtual char const * get_name() const { return "concat-model-converter"; }
+    char const * get_name() const override { return "concat-model-converter"; }
 
-    virtual model_converter * translate(ast_translation & translator) {
+    model_converter * translate(ast_translation & translator) override {
         return this->translate_core<concat_model_converter>(translator);
     }
 
-    virtual void collect(ast_pp_util& visitor) { 
+    void collect(ast_pp_util& visitor) override { 
         this->m_c1->collect(visitor);
         this->m_c2->collect(visitor);
     }
@@ -99,12 +104,12 @@ public:
         concat_star_converter<model_converter>(mc1, num, mc2s, szs) {
     }
 
-    virtual void operator()(model_ref & m) {
+    void operator()(model_ref & m) override {
         // TODO: delete method after conversion is complete
         UNREACHABLE();
     }
 
-    virtual void operator()(model_ref & m, unsigned goal_idx) {
+    void operator()(model_ref & m, unsigned goal_idx) override {
         unsigned num = this->m_c2s.size();
         for (unsigned i = 0; i < num; i++) {
             if (goal_idx < this->m_szs[i]) {
@@ -122,7 +127,7 @@ public:
         UNREACHABLE();
     }
 
-    virtual void operator()(labels_vec & r, unsigned goal_idx) {
+    void operator()(labels_vec & r, unsigned goal_idx) override {
         unsigned num = this->m_c2s.size();
         for (unsigned i = 0; i < num; i++) {
             if (goal_idx < this->m_szs[i]) {
@@ -140,9 +145,9 @@ public:
         UNREACHABLE();
     }
     
-    virtual char const * get_name() const { return "concat-star-model-converter"; }
+    char const * get_name() const override { return "concat-star-model-converter"; }
 
-    virtual model_converter * translate(ast_translation & translator) {
+    model_converter * translate(ast_translation & translator) override {
         return this->translate_core<concat_star_model_converter>(translator);
     }
 };
@@ -173,22 +178,28 @@ public:
 
     virtual ~model2mc() {}
 
-    virtual void operator()(model_ref & m) {
+    void operator()(model_ref & m) override {
         m = m_model;
     }
 
-    virtual void operator()(model_ref & m, unsigned goal_idx) {
+    void operator()(model_ref & m, unsigned goal_idx) override {
         m = m_model;
     }
 
-    virtual void operator()(labels_vec & r, unsigned goal_idx) {
+    void operator()(labels_vec & r, unsigned goal_idx) {
         r.append(m_labels.size(), m_labels.c_ptr());
     }
 
-    virtual void cancel() {
+    void operator()(expr_ref& fml) override {
+        expr_ref r(m_model->get_manager());
+        m_model->eval(fml, r, false);
+        fml = r;
+    }
+
+    void cancel() override {
     }
     
-    virtual void display(std::ostream & out) {
+    void display(std::ostream & out) override {
         out << "(model->model-converter-wrapper\n";
         model_v2_pp(out, *m_model);
         out << ")\n";
@@ -198,6 +209,7 @@ public:
         model * m = m_model->translate(translator);
         return alloc(model2mc, m);
     }
+
 };
 
 model_converter * model2model_converter(model * m) {

src/tactic/portfolio/bounded_int2bv_solver.cpp

@@ -22,7 +22,6 @@ Notes:
 #include "tactic/tactic.h"
 #include "ast/rewriter/pb2bv_rewriter.h"
 #include "tactic/generic_model_converter.h"
-#include "tactic/extension_model_converter.h"
 #include "ast/ast_pp.h"
 #include "model/model_smt2_pp.h"
 #include "tactic/arith/bound_manager.h"
@@ -215,17 +214,16 @@ private:
     }
 
     void extend_model(model_ref& mdl) {
-        extension_model_converter ext(m);
+        generic_model_converter ext(m);
-        obj_map<func_decl, func_decl*>::iterator it = m_int2bv.begin(), end = m_int2bv.end();
+        for (auto const& kv : m_int2bv) {
-        for (; it != end; ++it) {
             rational offset;
-            VERIFY (m_bv2offset.find(it->m_value, offset));
+            VERIFY (m_bv2offset.find(kv.m_value, offset));
-            expr_ref value(m_bv.mk_bv2int(m.mk_const(it->m_value)), m);
+            expr_ref value(m_bv.mk_bv2int(m.mk_const(kv.m_value)), m);
             if (!offset.is_zero()) {
                 value = m_arith.mk_add(value, m_arith.mk_numeral(offset, true));
             }
-            TRACE("int2bv", tout << mk_pp(it->m_key, m) << " " << value << "\n";);
+            TRACE("int2bv", tout << mk_pp(kv.m_key, m) << " " << value << "\n";);
-            ext.insert(it->m_key, value);
+            ext.add(kv.m_key, value);
         }
         ext(mdl, 0);
     }

src/tactic/portfolio/enum2bv_solver.cpp

@@ -25,7 +25,6 @@ Notes:
 #include "ast/ast_pp.h"
 #include "model/model_smt2_pp.h"
 #include "tactic/tactic.h"
-#include "tactic/extension_model_converter.h"
 #include "tactic/generic_model_converter.h"
 #include "tactic/portfolio/enum2bv_solver.h"
 #include "solver/solver_na2as.h"
@@ -172,9 +171,9 @@ public:
     }
 
     void extend_model(model_ref& mdl) {
-        extension_model_converter ext(m);
+        generic_model_converter ext(m);
         for (auto const& kv : m_rewriter.enum2def()) 
-            ext.insert(kv.m_key, kv.m_value);            
+            ext.add(kv.m_key, kv.m_value);            
         ext(mdl, 0);
     }
 

src/tactic/sine_filter.cpp

@@ -21,7 +21,6 @@ Revision History:
 #include "tactic/generic_model_converter.h"
 #include "ast/datatype_decl_plugin.h"
 #include "ast/rewriter/rewriter_def.h"
-#include "tactic/extension_model_converter.h"
 #include "ast/rewriter/var_subst.h"
 #include "ast/ast_util.h"
 #include "util/obj_pair_hashtable.h"

src/tactic/ufbv/macro_finder_tactic.cpp

@@ -19,7 +19,7 @@ Notes:
 #include "tactic/tactical.h"
 #include "ast/macros/macro_manager.h"
 #include "ast/macros/macro_finder.h"
-#include "tactic/extension_model_converter.h"
+#include "tactic/generic_model_converter.h"
 #include "tactic/ufbv/macro_finder_tactic.h"
 
 class macro_finder_tactic : public tactic {
@@ -69,12 +69,12 @@ class macro_finder_tactic : public tactic {
                                produce_proofs ? new_proofs.get(i) : 0,
                                unsat_core_enabled ? new_deps.get(i) : 0);
 
-            extension_model_converter * evmc = alloc(extension_model_converter, mm.get_manager());
+            generic_model_converter * evmc = alloc(generic_model_converter, mm.get_manager());
             unsigned num = mm.get_num_macros();
             for (unsigned i = 0; i < num; i++) {
                 expr_ref f_interp(mm.get_manager());
                 func_decl * f = mm.get_macro_interpretation(i, f_interp);
-                evmc->insert(f, f_interp);
+                evmc->add(f, f_interp);
             }
             mc = evmc;
 

src/tactic/ufbv/quasi_macros_tactic.cpp

@@ -17,9 +17,9 @@ Notes:
 
 --*/
 #include "tactic/tactical.h"
+#include "tactic/generic_model_converter.h"
 #include "ast/macros/macro_manager.h"
 #include "ast/macros/macro_finder.h"
-#include "tactic/extension_model_converter.h"
 #include "ast/macros/quasi_macros.h"
 #include "tactic/ufbv/quasi_macros_tactic.h"
 
@@ -81,12 +81,12 @@ class quasi_macros_tactic : public tactic {
                                produce_proofs ? proofs.get(i) : 0,
                                produce_unsat_cores ? deps.get(i) : 0);
 
-            extension_model_converter * evmc = alloc(extension_model_converter, mm.get_manager());
+            generic_model_converter * evmc = alloc(generic_model_converter, mm.get_manager());
             unsigned num = mm.get_num_macros();
             for (unsigned i = 0; i < num; i++) {
                 expr_ref f_interp(mm.get_manager());
                 func_decl * f = mm.get_macro_interpretation(i, f_interp);
-                evmc->insert(f, f_interp);
+                evmc->add(f, f_interp);
             }
             mc = evmc;