mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2026-07-03 05:46:08 +00:00
Code Activity

Refactor mk_and/mk_or call sites to use vector overloads (#8286)

Browse source 
* Initial plan

* Refactor mk_and and mk_or call sites to use overloaded methods

Changed 130 call sites across 64 files to use vector overloads directly instead of manually passing .size() and .data()/.c_ptr()

Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>

* Revert mk_or changes for ptr_buffer/ptr_vector (no overload exists in ast_util.h)

* Fix compilation errors from mk_and/mk_or refactoring

Fixed type mismatches by:
- Removing m parameter for expr_ref_vector (ast_util.h has mk_and/mk_or(expr_ref_vector) overloads)
- Reverting changes for ref_buffer types (no overload exists in ast_util.h, only in ast.h for m.mk_and)
- Verified build succeeds and Z3 works correctly

Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>

* Fix test files to use correct mk_and/mk_or overloads

Changed test/doc.cpp and test/udoc_relation.cpp to use mk_and(expr_ref_vector) and mk_or(expr_ref_vector) without m parameter

Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: NikolajBjorner <3085284+NikolajBjorner@users.noreply.github.com>
This commit is contained in:
Copilot 2026-01-22 13:21:22 -08:00 • committed by Nikolaj Bjorner
parent 21f10f0a5c
commit 1d417e3a0f
61 changed files with 118 additions and 118 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/smt/qi_queue.cpp
View file

@ -273,7 +273,7 @@ namespace smt {
ptr_vector<expr> args;
args.push_back(m.mk_not(q));
args.append(to_app(s_instance)->get_num_args(), to_app(s_instance)->get_args());
lemma = m.mk_or(args.size(), args.data());
lemma = m.mk_or(args);
}
else if (m.is_false(s_instance)) {
lemma = m.mk_not(q);

2
src/smt/smt_clause.cpp
View file

@ -122,7 +122,7 @@ namespace smt {
args.push_back(bool_var2expr_map[lit.var()]);
if (lit.sign()) args[args.size()-1] = m.mk_not(args.back());
}
expr_ref disj(m.mk_or(args.size(), args.data()), m);
expr_ref disj(m.mk_or(args), m);
return out << mk_pp(disj, m, 3);
}

2
src/smt/smt_conflict_resolution.cpp
View file

@ -1348,7 +1348,7 @@ namespace smt {
switch (lits.size()) {
case 0: fact = nullptr; break;
case 1: fact = lits[0]; break;
default: fact = m.mk_or(lits.size(), lits.data());
default: fact = m.mk_or(lits);
}
if (fact == nullptr)
m_lemma_proof = pr;

2
src/smt/smt_implied_equalities.cpp
View file

@ -550,7 +550,7 @@ namespace smt {
eqs.push_back(eq_lit);
m_solver.assert_expr(m.mk_implies(eq_lit, eq));
}
m_solver.assert_expr(m.mk_not(m.mk_and(eqs.size(), eqs.c_ptr())));
m_solver.assert_expr(m.mk_not(m.mk_and(eqs)));
lbool is_sat = m_solver.check_sat(0,0);
switch(is_sat) {
case l_false:

2
src/smt/smt_internalizer.cpp
View file

@ -1606,7 +1606,7 @@ namespace smt {
if (root_gate)
new_lits.push_back(m.mk_not(root_gate));
SASSERT(num_lits > 1);
expr * fact = m.mk_or(new_lits.size(), new_lits.data());
expr * fact = m.mk_or(new_lits);
return m.mk_def_axiom(fact);
}

4
src/smt/smt_justification.cpp
View file

@ -281,7 +281,7 @@ namespace smt {
if (lits.size() == 1)
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.data());
else
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.data()), 0, nullptr, m_params.size(), m_params.data());
return m.mk_th_lemma(m_th_id, m.mk_or(lits), 0, nullptr, m_params.size(), m_params.data());
}
proof * theory_propagation_justification::mk_proof(conflict_resolution & cr) {
@ -437,7 +437,7 @@ namespace smt {
if (lits.size() == 1)
return m.mk_th_lemma(m_th_id, lits.get(0), 0, nullptr, m_params.size(), m_params.data());
else
return m.mk_th_lemma(m_th_id, m.mk_or(lits.size(), lits.data()), 0, nullptr, m_params.size(), m_params.data());
return m.mk_th_lemma(m_th_id, m.mk_or(lits), 0, nullptr, m_params.size(), m_params.data());
}
};

4
src/smt/smt_model_checker.cpp
View file

@ -152,7 +152,7 @@ namespace smt {
for (expr * e : universe) {
eqs.push_back(m.mk_eq(sk, e));
}
expr_ref fml(m.mk_or(eqs.size(), eqs.data()), m);
expr_ref fml(m.mk_or(eqs), m);
m_aux_context->assert_expr(fml);
}
@ -319,7 +319,7 @@ namespace smt {
diseqs.push_back(m.mk_not(m.mk_eq(sk, sk_value)));
}
expr_ref blocking_clause(m);
blocking_clause = m.mk_or(diseqs.size(), diseqs.data());
blocking_clause = m.mk_or(diseqs);
TRACE(model_checker, tout << "blocking clause:\n" << mk_ismt2_pp(blocking_clause, m) << "\n";);
m_aux_context->assert_expr(blocking_clause);
return true;

2
src/smt/smt_model_finder.cpp
View file

@ -2562,7 +2562,7 @@ namespace smt {
eqs.push_back(m.mk_eq(sk, val));
}
expr_ref new_cnstr(m);
new_cnstr = m.mk_or(eqs.size(), eqs.data());
new_cnstr = m.mk_or(eqs);
TRACE(model_finder, tout << "assert_restriction:\n" << mk_pp(new_cnstr, m) << "\n";);
aux_ctx->assert_expr(new_cnstr);
asserted_something = true;

4
src/smt/tactic/ctx_solver_simplify_tactic.cpp
View file

@ -104,7 +104,7 @@ protected:
return;
ptr_vector<expr> fmls;
g.get_formulas(fmls);
fml = mk_and(m, fmls.size(), fmls.data());
fml = mk_and(m, fmls);
m_solver.push();
reduce(fml);
m_solver.pop(1);
@ -122,7 +122,7 @@ protected:
// enable_trace("after_search");
m_solver.push();
expr_ref fml1(m);
fml1 = mk_and(m, fmls.size(), fmls.data());
fml1 = mk_and(m, fmls);
fml1 = m.mk_iff(fml, fml1);
fml1 = m.mk_not(fml1);
m_solver.assert_expr(fml1);

4
src/smt/theory_dense_diff_logic_def.h
View file

@ -1093,7 +1093,7 @@ namespace smt {
else {
//
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.data());
f = m.mk_and(core);
if (is_strict) {
f = m.mk_not(f);
}
@ -1109,7 +1109,7 @@ namespace smt {
}
else {
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.data());
f = m.mk_and(core);
}
}
else {

6
src/smt/theory_diff_logic_def.h
View file

@ -1353,7 +1353,7 @@ expr_ref theory_diff_logic<Ext>::mk_ineq(theory_var v, inf_eps const& val, bool
else {
//
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.data());
f = m.mk_and(core);
if (is_strict) {
f = m.mk_not(f);
}
@ -1369,7 +1369,7 @@ expr_ref theory_diff_logic<Ext>::mk_ineq(theory_var v, inf_eps const& val, bool
}
else {
expr_ref_vector const& core = m_objective_assignments[v];
f = m.mk_and(core.size(), core.data());
f = m.mk_and(core);
}
}
else {
@ -1399,7 +1399,7 @@ expr_ref theory_diff_logic<Ext>::mk_ge(generic_model_converter& fm, theory_var v
ptr_vector<expr> formulas(ctx.get_num_asserted_formulas(), ctx.get_asserted_formulas());
model_implicant impl_extractor(m);
expr_ref_vector implicants = impl_extractor.minimize_literals(formulas, mdl);
return m.mk_and(o, m.mk_not(m.mk_and(implicants.size(), implicants.c_ptr())));
return m.mk_and(o, m.mk_not(m.mk_and(implicants)));
#endif
template<typename Ext>

8
src/smt/theory_pb.cpp
View file

@ -1280,7 +1280,7 @@ namespace smt {
ctx.literal2expr(lits[i], tmp);
es.push_back(tmp);
}
tmp = m.mk_or(es.size(), es.data());
tmp = m.mk_or(es);
bool_var v = ctx.b_internalized(tmp)?ctx.get_bool_var(tmp):ctx.mk_bool_var(tmp);
return literal(v);
}
@ -1292,7 +1292,7 @@ namespace smt {
ctx.literal2expr(lits[i], tmp);
es.push_back(tmp);
}
tmp = m.mk_and(es.size(), es.data());
tmp = m.mk_and(es);
bool_var v = ctx.b_internalized(tmp)?ctx.get_bool_var(tmp):ctx.mk_bool_var(tmp);
return literal(v);
}
@ -1624,7 +1624,7 @@ namespace smt {
literal lit = cls.get_literal(i);
args.push_back(literal2expr(lit));
}
result = m.mk_or(args.size(), args.data());
result = m.mk_or(args);
break;
}
case b_justification::BIN_CLAUSE:
@ -2025,7 +2025,7 @@ namespace smt {
for (literal lit : m_antecedents) {
args.push_back(literal2expr(lit));
}
B = m.mk_not(m.mk_and(args.size(), args.data()));
B = m.mk_not(m.mk_and(args));
validate_implies(A, B); );
return true;
}

2
src/smt/theory_wmaxsat.cpp
View file

@ -254,7 +254,7 @@ namespace smt {
//ctx.display(tout);
);
}
expr_ref result(m.mk_or(disj.size(), disj.data()), m);
expr_ref result(m.mk_or(disj), m);
TRACE(opt,
tout << result << " weight: " << weight << "\n";
tout << "cost: " << m_zcost << " min-cost: " << m_zmin_cost << "\n";);