merge with master

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

src/muz/transforms/dl_mk_slice.cpp

@@ -155,8 +155,8 @@ namespace datalog {
         }
 
         bool translate_asserted(proof* p) {
-            expr* fact = 0;
-            rule* r = 0;
+            expr* fact = nullptr;
+            rule* r = nullptr;
             if (!m.is_asserted(p, fact)) {
                 return false;   
             }
@@ -215,7 +215,7 @@ namespace datalog {
                 proof* p1_new = m_new_proof.find(p1);
                 expr* fact1   = m.get_fact(p1);
                 TRACE("dl", tout << "fact1: " << mk_pp(fact1, m) << "\n";);
-                rule* orig1 = 0;
+                rule* orig1 = nullptr;
                 if (!m_sliceform2rule.find(fact1, orig1)) {
                     return false;
                 }
@@ -282,7 +282,7 @@ namespace datalog {
         proof_converter * translate(ast_translation & translator) override {
             UNREACHABLE();
             // this would require implementing translation for the dl_context.
-            return 0;
+            return nullptr;
         }
 
         void display(std::ostream& out) override { out << "(slice-proof-converter)\n"; }
@@ -398,7 +398,7 @@ namespace datalog {
      
         model_converter * translate(ast_translation & translator) override {
             UNREACHABLE();
-            return 0;
+            return nullptr;
         }
 
         void display(std::ostream& out) override { out << "(slice-model-converter)\n"; }
@@ -412,8 +412,8 @@ namespace datalog {
         rm(ctx.get_rule_manager()), 
         m_solved_vars(m),
         m_pinned(m),
-        m_pc(0),
-        m_mc(0)
+        m_pc(nullptr),
+        m_mc(nullptr)
     {}
 
 
@@ -433,8 +433,8 @@ namespace datalog {
         bool change = true;
         while (change) {
             change = false;
-            for (unsigned i = 0; i < src.get_num_rules(); ++i) {
-                change = prune_rule(*src.get_rule(i)) || change;
+            for (rule* r : src) {
+                change = prune_rule(*r) || change;
             }
         }
     }
@@ -464,18 +464,19 @@ namespace datalog {
 
     void mk_slice::solve_vars(rule& r, uint_set& used_vars, uint_set& parameter_vars) {
         expr_ref_vector conjs = get_tail_conjs(r);
-        for (unsigned j = 0; j < conjs.size(); ++j) {
-            expr* e = conjs[j].get();
+        for (expr * e : conjs) {
             expr_ref r(m);
             unsigned v;
             if (is_eq(e, v, r) && is_output(v) && m_var_is_sliceable[v]) {
                 TRACE("dl", tout << "is_eq: " << mk_pp(e, m) << " " << (m_solved_vars[v].get()?"solved":"new") << "\n";);
                 add_var(v);
                 if (!m_solved_vars[v].get()) { 
+                    TRACE("dl", tout << v << " is solved\n";);
                     add_free_vars(parameter_vars, r);
                     m_solved_vars[v] = r;
                 }
                 else {
+                    TRACE("dl", tout << v << " is used\n";);
                     // variables can only be solved once.
                     add_free_vars(used_vars, e);
                     add_free_vars(used_vars, m_solved_vars[v].get());
@@ -515,10 +516,9 @@ namespace datalog {
         // 
         uint_set used_vars, parameter_vars;
         solve_vars(r, used_vars, parameter_vars);
-        uint_set::iterator it = used_vars.begin(), end = used_vars.end();
-        for (; it != end; ++it) {     
-            if (*it < m_var_is_sliceable.size()) {
-                m_var_is_sliceable[*it] = false;
+        for (unsigned uv : used_vars) {
+            if (uv < m_var_is_sliceable.size()) {
+                m_var_is_sliceable[uv] = false;
             }
         }
         //
@@ -540,6 +540,9 @@ namespace datalog {
                 if (m_solved_vars[i].get()) {
                     m_var_is_sliceable[i] = false;
                 }
+                if (parameter_vars.contains(i)) {
+                    m_var_is_sliceable[i] = false;
+                }
             }
             else if (is_output) {
                 if (parameter_vars.contains(i)) {
@@ -694,11 +697,9 @@ namespace datalog {
     }
 
     void mk_slice::display(std::ostream& out) {
-        obj_map<func_decl, bit_vector>::iterator it  = m_sliceable.begin();
-        obj_map<func_decl, bit_vector>::iterator end = m_sliceable.end();
-        for (; it != end; ++it) {
-            out << it->m_key->get_name() << " ";
-            bit_vector const& bv = it->m_value;
+        for (auto const& kv : m_sliceable) {
+            out << kv.m_key->get_name() << " ";
+            bit_vector const& bv = kv.m_value;
             for (unsigned i = 0; i < bv.size(); ++i) {
                 out << (bv.get(i)?"1":"0");
             }
@@ -796,7 +797,7 @@ namespace datalog {
                 tail.push_back(to_app(e));                
             }
                         
-            new_rule = rm.mk(head.get(), tail.size(), tail.c_ptr(), (const bool*) 0, r.name());        
+            new_rule = rm.mk(head.get(), tail.size(), tail.c_ptr(), (const bool*) nullptr, r.name());
 
             rm.fix_unbound_vars(new_rule, false);
 
@@ -811,7 +812,7 @@ namespace datalog {
         dst.add_rule(new_rule.get());
 
         if (m_pc) {
-            m_pc->insert(&r, new_rule.get(), 0, 0);
+            m_pc->insert(&r, new_rule.get(), 0, nullptr);
         }
     }
 
@@ -825,7 +826,7 @@ namespace datalog {
         rule_manager& rm = m_ctx.get_rule_manager();       
         for (unsigned i = 0; i < src.get_num_rules(); ++i) {
             if (rm.has_quantifiers(*src.get_rule(i))) {
-                return 0;
+                return nullptr;
             }
         }
         ref<slice_proof_converter> spc;
@@ -845,7 +846,7 @@ namespace datalog {
         if (m_predicates.empty()) {
             // nothing could be sliced.
             dealloc(result);
-            return 0;
+            return nullptr;
         }
         TRACE("dl", display(tout););        
         update_rules(src, *result);