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

* 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>

src/ast/macros/quasi_macros.cpp

@@ -262,7 +262,7 @@ bool quasi_macros::quasi_macro_to_macro(quantifier * q, app * a, expr * t, quant
                                                   f->get_arity(), f->get_domain(),
                                                   f->get_range());
     expr_ref f_else(m.mk_app(fd, m_new_vars.size(), m_new_vars.data()), m);
-    expr_ref ite(m.mk_ite(m.mk_and(m_new_eqs.size(), m_new_eqs.data()), t, f_else), m);
+    expr_ref ite(m.mk_ite(m.mk_and(m_new_eqs), t, f_else), m);
 
     expr_ref eq(m.mk_eq(appl, ite), m);
 

src/ast/proofs/proof_checker.cpp

@@ -170,7 +170,7 @@ bool proof_checker::check1_spc(proof* p, expr_ref_vector& side_conditions) {
                 }
             }
             expr_ref rewrite_cond(m);
-            rewrite_cond = m.mk_or(rewrite_eq.size(), rewrite_eq.c_ptr());
+            rewrite_cond = m.mk_or(rewrite_eq);
             side_conditions.push_back(rewrite_cond.get());
             return true;
         }
@@ -431,7 +431,7 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) {
                 }
             }
             expr_ref rewrite_cond(m);
-            rewrite_cond = m.mk_or(rewrite_eq.size(), rewrite_eq.data());
+            rewrite_cond = m.mk_or(rewrite_eq);
             side_conditions.push_back(rewrite_cond.get());
             return true;
         }
@@ -819,7 +819,7 @@ bool proof_checker::check1_basic(proof* p, expr_ref_vector& side_conditions) {
             fmls[i] = premise1;
         }
         fmls[0] = premise0;
-        premise0 = m.mk_or(fmls.size(), fmls.data());
+        premise0 = m.mk_or(fmls);
         if (is_forall(conclusion)) {
             quantifier* q = to_quantifier(conclusion);
             premise0 = m.mk_iff(premise0, q->get_expr());
@@ -861,7 +861,7 @@ void proof_checker::set_false(expr_ref& e, unsigned position, expr_ref& lit) {
         args.append(a->get_num_args(), a->get_args());
         lit = args[position].get();
         args[position] = m.mk_false();
-        e = m.mk_or(args.size(), args.data());
+        e = m.mk_or(args);
     }
     else if (m.is_implies(e, body, head)) {
         expr* const* heads = &head;
@@ -880,14 +880,14 @@ void proof_checker::set_false(expr_ref& e, unsigned position, expr_ref& lit) {
             args.append(num_heads, heads);
             lit = args[position].get();
             args[position] = m.mk_false();
-            e = m.mk_implies(body, m.mk_or(args.size(), args.data()));
+            e = m.mk_implies(body, m.mk_or(args));
         }
         else {
             position -= num_heads;
             args.append(num_bodies, bodies);
             lit = m.mk_not(args[position].get());
             args[position] = m.mk_true();
-            e = m.mk_implies(m.mk_and(args.size(), args.data()), head);
+            e = m.mk_implies(m.mk_and(args), head);
         }
     }
     else if (position == 0) {

src/ast/proofs/proof_utils.cpp

@@ -556,7 +556,7 @@ public:
                     clause = m_literals[0];
                 }
                 else {
-                    clause = m.mk_or(m_literals.size(), m_literals.data());
+                    clause = m.mk_or(m_literals);
                 }
                 tmp = m.mk_lemma(tmp, clause);
                 m_refs.push_back(tmp);

src/ast/rewriter/bv_bounds.cpp

@@ -320,8 +320,8 @@ br_status bv_bounds::rewrite(unsigned limit, func_decl * f, unsigned num, expr *
     switch (nargs.size()) {
         case 0: result = negated ? m_m.mk_false() : m_m.mk_true(); return BR_DONE;
         case 1: result = nargs.get(0); return BR_DONE;
-        default: result = negated ? m_m.mk_or(nargs.size(), nargs.data())
-                                  : m_m.mk_and(nargs.size(), nargs.data());
+        default: result = negated ? m_m.mk_or(nargs)
+                                  : m_m.mk_and(nargs);
                  return BR_DONE;
     }
 }

src/ast/rewriter/elim_bounds.cpp

@@ -188,7 +188,7 @@ bool elim_bounds_cfg::reduce_quantifier(quantifier * q,
         new_body = atoms[0];
         break;
     default:
-        new_body = m.mk_or(atoms.size(), atoms.data());
+        new_body = m.mk_or(atoms);
         break;
     }
     quantifier_ref new_q(m);

src/ast/rewriter/pb_rewriter.cpp

@@ -170,7 +170,7 @@ expr_ref pb_rewriter::mk_validate_rewrite(app_ref& e1, app_ref& e2) {
     expr_ref fml2 = translate_pb2lia(vars, e2);    
     tmp = m.mk_not(m.mk_eq(fml1, fml2));
     fmls.push_back(tmp);
-    tmp = m.mk_and(fmls.size(), fmls.data());
+    tmp = m.mk_and(fmls);
     return tmp;
 }