mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-18 09:12:16 +00:00
Code Activity

refactor get_sort

Browse source
This commit is contained in:
Nikolaj Bjorner 2021-02-02 04:45:54 -08:00
parent 4455f6caf8
commit 3ae4c6e9de
129 changed files with 362 additions and 362 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/ast/arith_decl_plugin.cpp
View file

@ -496,7 +496,7 @@ static bool has_real_arg(unsigned arity, sort * const * domain, sort * real_sort
static bool has_real_arg(ast_manager * m, unsigned num_args, expr * const * args, sort * real_sort) {
for (unsigned i = 0; i < num_args; i++)
if (m->get_sort(args[i]) == real_sort)
if (args[i]->get_sort() == real_sort)
return true;
return false;
}
@ -543,7 +543,7 @@ func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
return nullptr;
}
if (k == OP_IDIVIDES) {
if (num_args != 1 || m_manager->get_sort(args[0]) != m_int_decl || num_parameters != 1 || !parameters[0].is_int()) {
if (num_args != 1 || args[0]->get_sort() != m_int_decl || num_parameters != 1 || !parameters[0].is_int()) {
m_manager->raise_exception("invalid divides application. Expects integer parameter and one argument of sort integer");
}
return m_manager->mk_func_decl(symbol("divisible"), 1, &m_int_decl, m_manager->mk_bool_sort(),
@ -553,7 +553,7 @@ func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
return mk_func_decl(fix_kind(k, num_args), has_real_arg(m_manager, num_args, args, m_real_decl));
}
else {
bool is_real = num_args > 0 && m_manager->get_sort(args[0]) == m_real_decl;
bool is_real = num_args > 0 && args[0]->get_sort() == m_real_decl;
return mk_func_decl(fix_kind(k, num_args), is_real);
}
}

34
src/ast/ast.cpp
View file

@ -689,7 +689,7 @@ func_decl * decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, para
unsigned num_args, expr * const * args, sort * range) {
ptr_buffer<sort> sorts;
for (unsigned i = 0; i < num_args; i++) {
sorts.push_back(m_manager->get_sort(args[i]));
sorts.push_back(args[i]->get_sort());
}
return mk_func_decl(k, num_parameters, parameters, num_args, sorts.c_ptr(), range);
}
@ -769,11 +769,11 @@ bool basic_decl_plugin::check_proof_args(basic_op_kind k, unsigned num_args, exp
return false;
else {
for (unsigned i = 0; i < num_args - 1; i++)
if (m_manager->get_sort(args[i]) != m_proof_sort)
if (args[i]->get_sort() != m_proof_sort)
return false;
return
m_manager->get_sort(args[num_args - 1]) == m_bool_sort ||
m_manager->get_sort(args[num_args - 1]) == m_proof_sort ||
args[num_args - 1]->get_sort() == m_bool_sort ||
args[num_args - 1]->get_sort() == m_proof_sort ||
is_lambda(args[num_args-1]);
}
}
@ -1098,11 +1098,11 @@ sort* basic_decl_plugin::join(unsigned n, sort* const* srts) {
sort* basic_decl_plugin::join(unsigned n, expr* const* es) {
SASSERT(n > 0);
sort* s = m_manager->get_sort(*es);
sort* s = es[0]->get_sort();
while (n > 1) {
++es;
--n;
s = join(s, m_manager->get_sort(*es));
s = join(s, (*es)->get_sort());
}
return s;
}
@ -1179,7 +1179,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
case OP_NOT: return m_not_decl;
case OP_IMPLIES: return m_implies_decl;
case OP_XOR: return m_xor_decl;
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(m_manager->get_sort(args[1]), m_manager->get_sort(args[2]))): nullptr;
case OP_ITE: return num_args == 3 ? mk_ite_decl(join(args[1]->get_sort(), args[2]->get_sort())): nullptr;
// eq and oeq must have at least two arguments, they can have more since they are chainable
case OP_EQ: return num_args >= 2 ? mk_eq_decl_core("=", OP_EQ, join(num_args, args), m_eq_decls) : nullptr;
case OP_OEQ: return num_args >= 2 ? mk_eq_decl_core("~", OP_OEQ, join(num_args, args), m_oeq_decls) : nullptr;
@ -1187,7 +1187,7 @@ func_decl * basic_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
return decl_plugin::mk_func_decl(k, num_parameters, parameters, num_args, args, range);
case PR_BIND: {
ptr_buffer<sort> sorts;
for (unsigned i = 0; i < num_args; ++i) sorts.push_back(m_manager->get_sort(args[i]));
for (unsigned i = 0; i < num_args; ++i) sorts.push_back(args[i]->get_sort());
return mk_func_decl(k, num_parameters, parameters, num_args, sorts.c_ptr(), range);
}
default:
@ -1763,7 +1763,7 @@ void ast_manager::register_plugin(family_id id, decl_plugin * plugin) {
}
bool ast_manager::is_bool(expr const * n) const {
return get_sort(n) == m_bool_sort;
return n->get_sort() == m_bool_sort;
}
#ifdef Z3DEBUG
@ -2106,7 +2106,7 @@ void ast_manager::check_sort(func_decl const * decl, unsigned num_args, expr * c
if (decl->is_associative()) {
sort * expected = decl->get_domain(0);
for (unsigned i = 0; i < num_args; i++) {
sort * given = get_sort(args[i]);
sort * given = args[i]->get_sort();
if (!compatible_sorts(expected, given)) {
std::ostringstream buff;
buff << "invalid function application for " << decl->get_name() << ", ";
@ -2122,7 +2122,7 @@ void ast_manager::check_sort(func_decl const * decl, unsigned num_args, expr * c
}
for (unsigned i = 0; i < num_args; i++) {
sort * expected = decl->get_domain(i);
sort * given = get_sort(args[i]);
sort * given = args[i]->get_sort();
if (!compatible_sorts(expected, given)) {
std::ostringstream buff;
buff << "invalid function application for " << decl->get_name() << ", ";
@ -2186,7 +2186,7 @@ bool ast_manager::coercion_needed(func_decl * decl, unsigned num_args, expr * co
sort * d = decl->get_domain(0);
if (d->get_family_id() == m_arith_family_id) {
for (unsigned i = 0; i < num_args; i++) {
if (d != get_sort(args[i]))
if (d != args[i]->get_sort())
return true;
}
}
@ -2199,7 +2199,7 @@ bool ast_manager::coercion_needed(func_decl * decl, unsigned num_args, expr * co
}
for (unsigned i = 0; i < num_args; i++) {
sort * d = decl->get_domain(i);
if (d->get_family_id() == m_arith_family_id && d != get_sort(args[i]))
if (d->get_family_id() == m_arith_family_id && d != args[i]->get_sort())
return true;
}
}
@ -2207,7 +2207,7 @@ bool ast_manager::coercion_needed(func_decl * decl, unsigned num_args, expr * co
}
expr* ast_manager::coerce_to(expr* e, sort* s) {
sort* se = get_sort(e);
sort* se = e->get_sort();
if (s != se && s->get_family_id() == m_arith_family_id && se->get_family_id() == m_arith_family_id) {
if (s->get_decl_kind() == REAL_SORT) {
return mk_app(m_arith_family_id, OP_TO_REAL, e);
@ -2277,7 +2277,7 @@ app * ast_manager::mk_app_core(func_decl * decl, unsigned num_args, expr * const
void ast_manager::check_args(func_decl* f, unsigned n, expr* const* es) {
for (unsigned i = 0; i < n; i++) {
sort * actual_sort = get_sort(es[i]);
sort * actual_sort = es[i]->get_sort();
sort * expected_sort = f->is_associative() ? f->get_domain(0) : f->get_domain(i);
if (expected_sort != actual_sort) {
std::ostringstream buffer;
@ -2959,14 +2959,14 @@ proof * ast_manager::mk_monotonicity(func_decl * R, app * f1, app * f2, unsigned
proof * ast_manager::mk_congruence(app * f1, app * f2, unsigned num_proofs, proof * const * proofs) {
SASSERT(get_sort(f1) == get_sort(f2));
sort * s = get_sort(f1);
sort * s = f1->get_sort();
sort * d[2] = { s, s };
return mk_monotonicity(mk_func_decl(m_basic_family_id, get_eq_op(f1), 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
}
proof * ast_manager::mk_oeq_congruence(app * f1, app * f2, unsigned num_proofs, proof * const * proofs) {
SASSERT(get_sort(f1) == get_sort(f2));
sort * s = get_sort(f1);
sort * s = f1->get_sort();
sort * d[2] = { s, s };
return mk_monotonicity(mk_func_decl(m_basic_family_id, OP_OEQ, 0, nullptr, 2, d), f1, f2, num_proofs, proofs);
}

2
src/ast/ast.h
View file

@ -2311,7 +2311,7 @@ public:
bool has_fact(proof const * p) const {
SASSERT(is_proof(p));
unsigned n = p->get_num_args();
return n > 0 && get_sort(p->get_arg(n - 1)) != m_proof_sort;
return n > 0 && p->get_arg(n - 1)->get_sort() != m_proof_sort;
}
expr * get_fact(proof const * p) const { SASSERT(is_proof(p)); SASSERT(has_fact(p)); return p->get_arg(p->get_num_args() - 1); }

10
src/ast/ast_smt_pp.cpp
View file

@ -197,7 +197,7 @@ class smt_printer {
}
bool is_bool(expr* e) {
return is_bool(m_manager.get_sort(e));
return is_bool(e->get_sort());
}
bool is_proof(sort* s) {
@ -207,7 +207,7 @@ class smt_printer {
}
bool is_proof(expr* e) {
return is_proof(m_manager.get_sort(e));
return is_proof(e->get_sort());
}
void pp_id(expr* n) {
@ -450,11 +450,11 @@ class smt_printer {
while (idx < args.size() && !args[idx])
idx++;
if (idx >= args.size()) break;
sort * s = m_manager.get_sort(args[idx]);
sort * s = args[idx]->get_sort();
unsigned next = idx + 1;
// check if there is only a single one
while (next < args.size() && (!args[next] || m_manager.get_sort(args[next]) != s))
while (next < args.size() && (!args[next] || args[next]->get_sort() != s))
next++;
if (next >= args.size()) {
args[idx] = 0;
@ -465,7 +465,7 @@ class smt_printer {
// otherwise print all of the relevant sort
m_out << " (distinct";
for (unsigned i = idx; i < args.size(); ++i) {
if (args[i] && s == m_manager.get_sort(args[i])) {
if (args[i] && s == args[i]->get_sort()) {
m_out << " ";
pp_marked_expr(args[i]);
args[i] = 0;

6
src/ast/bv_decl_plugin.cpp
View file

@ -350,7 +350,7 @@ inline bool bv_decl_plugin::get_bv_size(sort * s, int & result) {
}
inline bool bv_decl_plugin::get_bv_size(expr * t, int & result) {
return get_bv_size(m_manager->get_sort(t), result);
return get_bv_size(t->get_sort(), result);
}
bool bv_decl_plugin::get_concat_size(unsigned arity, sort * const * domain, int & result) {
@ -604,7 +604,7 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
if (r->get_info()->is_associative()) {
sort * fs = r->get_domain(0);
for (unsigned i = 0; i < num_args; ++i) {
if (m.get_sort(args[i]) != fs) {
if (args[i]->get_sort() != fs) {
m_manager->raise_exception("declared sorts do not match supplied sorts");
return nullptr;
}
@ -617,7 +617,7 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
}
}
for (unsigned i = 0; i < num_args; ++i) {
if (m.get_sort(args[i]) != r->get_domain(i)) {
if (args[i]->get_sort() != r->get_domain(i)) {
std::ostringstream buffer;
buffer << "Argument " << mk_pp(args[i], m) << " at position " << i << " does not match declaration " << mk_pp(r, m);
m.raise_exception(buffer.str());

2
src/ast/bv_decl_plugin.h
View file

@ -398,7 +398,7 @@ public:
SASSERT(is_bv_sort(s));
return static_cast<unsigned>(s->get_parameter(0).get_int());
}
unsigned get_bv_size(expr const * n) const { return get_bv_size(m_manager.get_sort(n)); }
unsigned get_bv_size(expr const * n) const { return get_bv_size(n->get_sort()); }
unsigned get_int2bv_size(parameter const& p);

4
src/ast/dl_decl_plugin.cpp
View file

@ -297,7 +297,7 @@ namespace datalog {
m_manager->raise_exception("illegal index");
return nullptr;
}
if (sorts[idx] != m.get_sort(e)) {
if (sorts[idx] != e->get_sort()) {
m_manager->raise_exception("sort mismatch in filter");
return nullptr;
}
@ -766,7 +766,7 @@ namespace datalog {
app* dl_decl_util::mk_rule(symbol const& name, unsigned num_args, expr* const* args) {
ptr_buffer<sort> sorts;
for (unsigned i = 0; i < num_args; ++i) {
sorts.push_back(m.get_sort(args[i]));
sorts.push_back(args[i]->get_sort());
}
func_decl* f = m.mk_func_decl(name, num_args, sorts.c_ptr(), mk_rule_sort());
return m.mk_app(f, num_args, args);

2
src/ast/dl_decl_plugin.h
View file

@ -180,7 +180,7 @@ namespace datalog {
}
bool is_finite_sort(expr* e) const {
return is_finite_sort(m.get_sort(e));
return is_finite_sort(e->get_sort());
}
bool is_rule_sort(sort* s) const {

2
src/ast/euf/euf_egraph.cpp
View file

@ -560,7 +560,7 @@ namespace euf {
return false;
if (ra->interpreted() && rb->interpreted())
return true;
if (m.get_sort(ra->get_expr()) != m.get_sort(rb->get_expr()))
if (ra->get_expr()->get_sort() != rb->get_expr()->get_sort())
return true;
expr_ref eq(m.mk_eq(a->get_expr(), b->get_expr()), m);
m_tmp_eq->m_args[0] = a;

4
src/ast/expr_abstract.cpp
View file

@ -34,7 +34,7 @@ void expr_abstractor::operator()(unsigned base, unsigned num_bound, expr* const*
for (unsigned i = 0; i < num_bound; ++i) {
b = bound[i];
expr* v = m.mk_var(base + num_bound - i - 1, m.get_sort(b));
expr* v = m.mk_var(base + num_bound - i - 1, b->get_sort());
m_pinned.push_back(v);
m_map.insert(b, v);
}
@ -122,7 +122,7 @@ expr_ref mk_quantifier(quantifier_kind k, ast_manager& m, unsigned num_bound, ap
ptr_vector<sort> sorts;
svector<symbol> names;
for (unsigned i = 0; i < num_bound; ++i) {
sorts.push_back(m.get_sort(bound[i]));
sorts.push_back(bound[i]->get_sort());
names.push_back(bound[i]->get_decl()->get_name());
}
result = m.mk_quantifier(k, num_bound, sorts.c_ptr(), names.c_ptr(), result);

2
src/ast/fpa/bv2fpa_converter.cpp
View file

@ -217,7 +217,7 @@ expr_ref bv2fpa_converter::rebuild_floats(model_core * mc, sort * s, expr * e) {
app * a = to_app(e);
expr_ref_vector new_args(m);
for (expr* arg : *a) {
new_args.push_back(rebuild_floats(mc, m.get_sort(arg), arg));
new_args.push_back(rebuild_floats(mc, arg->get_sort(), arg));
}
result = m.mk_app(a->get_decl(), new_args.size(), new_args.c_ptr());
}

14
src/ast/fpa/fpa2bv_converter.cpp
View file

@ -2475,8 +2475,8 @@ void fpa2bv_converter::mk_to_fp_float(func_decl * f, sort * s, expr * rm, expr *
}
void fpa2bv_converter::mk_to_fp_float(sort * to_srt, expr * rm, expr * x, expr_ref & result) {
unsigned from_sbits = m_util.get_sbits(m.get_sort(x));
unsigned from_ebits = m_util.get_ebits(m.get_sort(x));
unsigned from_sbits = m_util.get_sbits(x->get_sort());
unsigned from_ebits = m_util.get_ebits(x->get_sort());
unsigned to_sbits = m_util.get_sbits(to_srt);
unsigned to_ebits = m_util.get_ebits(to_srt);
@ -2844,7 +2844,7 @@ void fpa2bv_converter::mk_to_real(func_decl * f, unsigned num, expr * const * ar
SASSERT(is_app_of(args[0], m_plugin->get_family_id(), OP_FPA_FP));
expr * x = args[0];
sort * s = m.get_sort(x);
sort * s = x->get_sort();
unsigned ebits = m_util.get_ebits(s);
unsigned sbits = m_util.get_sbits(s);
@ -3252,7 +3252,7 @@ void fpa2bv_converter::mk_to_bv(func_decl * f, unsigned num, expr * const * args
expr * rm = to_app(args[0])->get_arg(0);
expr * x = args[1];
sort * xs = m.get_sort(x);
sort * xs = x->get_sort();
sort * bv_srt = f->get_range();
expr_ref sgn(m), sig(m), exp(m), lz(m);
@ -3421,7 +3421,7 @@ void fpa2bv_converter::mk_to_sbv(func_decl * f, unsigned num, expr * const * arg
expr_ref fpa2bv_converter::nan_wrap(expr * n) {
expr_ref n_bv(m), arg_is_nan(m), nan(m), nan_bv(m), res(m);
mk_is_nan(n, arg_is_nan);
mk_nan(m.get_sort(n), nan);
mk_nan(n->get_sort(), nan);
join_fp(nan, nan_bv);
join_fp(n, n_bv);
res = expr_ref(m.mk_ite(arg_is_nan, nan_bv, n_bv), m);
@ -3845,7 +3845,7 @@ void fpa2bv_converter::dbg_decouple(const char * prefix, expr_ref & e) {
}
else {
expr_ref new_e(m), new_e_eq_e(m);
new_e = m.mk_fresh_const(prefix, m.get_sort(e));
new_e = m.mk_fresh_const(prefix, e->get_sort());
new_e_eq_e = m.mk_eq(new_e, e);
m_extra_assertions.push_back(new_e_eq_e);
e = new_e;
@ -4279,7 +4279,7 @@ app_ref fpa2bv_converter_wrapped::wrap(expr* e) {
res = to_app(tmp);
}
else {
sort* es = m.get_sort(e);
sort* es = e->get_sort();
sort_ref bv_srt(m);
if (is_rm(es))

2
src/ast/fpa/fpa2bv_rewriter.cpp
View file

@ -73,7 +73,7 @@ br_status fpa2bv_rewriter_cfg::reduce_app(func_decl * f, unsigned num, expr * co
SASSERT(num == 2);
TRACE("fpa2bv_rw", tout << "(= " << mk_ismt2_pp(args[0], m()) << " " <<
mk_ismt2_pp(args[1], m()) << ")" << std::endl;);
SASSERT(m().get_sort(args[0]) == m().get_sort(args[1]));
SASSERT(args[0]->get_sort() == args[1]->get_sort());
sort * ds = f->get_domain()[0];
if (m_conv.is_float(ds)) {
m_conv.mk_eq(args[0], args[1], result);

4
src/ast/fpa_decl_plugin.h
View file

@ -223,8 +223,8 @@ public:
sort * mk_rm_sort() { return m().mk_sort(m_fid, ROUNDING_MODE_SORT); }
bool is_float(sort * s) const { return is_sort_of(s, m_fid, FLOATING_POINT_SORT); }
bool is_rm(sort * s) const { return is_sort_of(s, m_fid, ROUNDING_MODE_SORT); }
bool is_float(expr * e) const { return is_float(m_manager.get_sort(e)); }
bool is_rm(expr * e) const { return is_rm(m_manager.get_sort(e)); }
bool is_float(expr * e) const { return is_float(e->get_sort()); }
bool is_rm(expr * e) const { return is_rm(e->get_sort()); }
bool is_fp(expr const * e) const { return is_app_of(e, m_fid, OP_FPA_FP); }
unsigned get_ebits(sort * s) const;
unsigned get_sbits(sort * s) const;

10
src/ast/macros/macro_util.cpp
View file

@ -307,7 +307,7 @@ bool macro_util::is_pseudo_head(expr * n, unsigned num_decls, app_ref & head, ap
return false;
if (!is_ground(lhs) && !is_ground(rhs))
return false;
sort * s = m_manager.get_sort(lhs);
sort * s = lhs->get_sort();
if (m_manager.is_uninterp(s))
return false;
sort_size sz = s->get_num_elements();
@ -448,7 +448,7 @@ void macro_util::quasi_macro_head_to_macro_head(app * qhead, unsigned & num_decl
continue;
}
}
var * new_var = m_manager.mk_var(next_var_idx, m_manager.get_sort(arg));
var * new_var = m_manager.mk_var(next_var_idx, arg->get_sort());
next_var_idx++;
expr * new_cond = m_manager.mk_eq(new_var, arg);
new_args.push_back(new_var);
@ -609,7 +609,7 @@ void hint_to_macro_head(ast_manager & m, app * head, unsigned & num_decls, app_r
continue;
}
}
var * new_var = m.mk_var(next_var_idx, m.get_sort(arg));
var * new_var = m.mk_var(next_var_idx, arg->get_sort());
next_var_idx++;
new_args.push_back(new_var);
}
@ -820,7 +820,7 @@ void macro_util::collect_arith_macro_candidates(expr * lhs, expr * rhs, expr * a
if (_is_arith_macro || _is_poly_hint) {
collect_poly_args(lhs, arg, args);
expr_ref rest(m_manager);
mk_add(args.size(), args.c_ptr(), m_manager.get_sort(arg), rest);
mk_add(args.size(), args.c_ptr(), arg->get_sort(), rest);
expr_ref def(m_manager);
mk_sub(rhs, rest, def);
// If is_poly_hint, rhs may contain variables that do not occur in to_app(arg).
@ -841,7 +841,7 @@ void macro_util::collect_arith_macro_candidates(expr * lhs, expr * rhs, expr * a
if (_is_arith_macro || _is_poly_hint) {
collect_poly_args(lhs, arg, args);
expr_ref rest(m_manager);
mk_add(args.size(), args.c_ptr(), m_manager.get_sort(arg), rest);
mk_add(args.size(), args.c_ptr(), arg->get_sort(), rest);
expr_ref def(m_manager);
mk_sub(rest, rhs, def);
// If is_poly_hint, rhs may contain variables that do not occur in to_app(neg_arg).

2
src/ast/normal_forms/defined_names.cpp
View file

@ -119,7 +119,7 @@ app * defined_names::impl::gen_name(expr * e, sort_ref_buffer & var_sorts, buffe
var_names.push_back(symbol(i));
}
sort * range = m.get_sort(e);
sort * range = e->get_sort();
func_decl * new_skolem_decl = m.mk_fresh_func_decl(m_z3name, symbol::null, domain.size(), domain.c_ptr(), range);
app * n = m.mk_app(new_skolem_decl, new_args.size(), new_args.c_ptr());
if (is_lambda(e)) {

4
src/ast/proofs/proof_checker.cpp
View file

@ -1278,7 +1278,7 @@ bool proof_checker::check_arith_literal(bool is_pos, app* lit0, rational const&
return false;
}
SASSERT(lit->get_num_args() == 2);
sort* s = m.get_sort(lit->get_arg(0));
sort* s = lit->get_arg(0)->get_sort();
bool is_int = a.is_int(s);
if (!is_int && a.is_int_expr(lit->get_arg(0))) {
is_int = true;
@ -1425,7 +1425,7 @@ bool proof_checker::check_arith_proof(proof* p) {
return false;
}
sort* s = m.get_sort(sum);
sort* s = sum->get_sort();
if (is_strict) {

2
src/ast/recfun_decl_plugin.cpp
View file

@ -501,7 +501,7 @@ namespace recfun {
}
symbol fresh_name(m().mk_fresh_id());
auto pd = mk_def(fresh_name, n, domain.c_ptr(), m().get_sort(max_expr));
auto pd = mk_def(fresh_name, n, domain.c_ptr(), max_expr->get_sort());
func_decl* f = pd.get_def()->get_decl();
expr_ref new_body(m().mk_app(f, n, args.c_ptr()), m());
set_definition(subst, pd, n, vars, max_expr);

10
src/ast/rewriter/arith_rewriter.cpp
View file

@ -342,7 +342,7 @@ br_status arith_rewriter::is_separated(expr* arg1, expr* arg2, op_kind kind, exp
}
SASSERT(r1 == r2);
expr_ref zero(m_util.mk_numeral(rational(0), m().get_sort(arg1)), m());
expr_ref zero(m_util.mk_numeral(rational(0), arg1->get_sort()), m());
if (r1.is_zero() && m_util.is_mul(arg1)) {
expr_ref_buffer eqs(m());
@ -931,7 +931,7 @@ br_status arith_rewriter::mk_div_core(expr * arg1, expr * arg2, expr_ref & resul
if (m_util.is_irrational_algebraic_numeral(arg2) && m_util.is_numeral(arg1))
return mk_div_rat_irrat(arg1, arg2, result);
}
set_curr_sort(m().get_sort(arg1));
set_curr_sort(arg1->get_sort());
numeral v1, v2;
bool is_int;
if (m_util.is_numeral(arg2, v2, is_int)) {
@ -992,7 +992,7 @@ br_status arith_rewriter::mk_idivides(unsigned k, expr * arg, expr_ref & result)
}
br_status arith_rewriter::mk_idiv_core(expr * arg1, expr * arg2, expr_ref & result) {
set_curr_sort(m().get_sort(arg1));
set_curr_sort(arg1->get_sort());
numeral v1, v2;
bool is_int;
if (m_util.is_numeral(arg1, v1, is_int) && m_util.is_numeral(arg2, v2, is_int) && !v2.is_zero()) {
@ -1142,7 +1142,7 @@ static rational symmod(rational const& a, rational const& b) {
}
br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & result) {
set_curr_sort(m().get_sort(arg1));
set_curr_sort(arg1->get_sort());
numeral v1, v2;
bool is_int;
if (m_util.is_numeral(arg1, v1, is_int) && m_util.is_numeral(arg2, v2, is_int) && !v2.is_zero()) {
@ -1203,7 +1203,7 @@ br_status arith_rewriter::mk_mod_core(expr * arg1, expr * arg2, expr_ref & resul
}
br_status arith_rewriter::mk_rem_core(expr * arg1, expr * arg2, expr_ref & result) {
set_curr_sort(m().get_sort(arg1));
set_curr_sort(arg1->get_sort());
numeral v1, v2;
bool is_int;
if (m_util.is_numeral(arg1, v1, is_int) && m_util.is_numeral(arg2, v2, is_int) && !v2.is_zero()) {

8
src/ast/rewriter/array_rewriter.cpp
View file

@ -267,7 +267,7 @@ br_status array_rewriter::mk_select_core(unsigned num_args, expr * const * args,
}
sort_ref array_rewriter::get_map_array_sort(func_decl* f, unsigned num_args, expr* const* args) {
sort* s0 = m().get_sort(args[0]);
sort* s0 = args[0]->get_sort();
unsigned sz = get_array_arity(s0);
ptr_vector<sort> domain;
for (unsigned i = 0; i < sz; ++i) domain.push_back(get_array_domain(s0, i));
@ -533,7 +533,7 @@ br_status array_rewriter::mk_set_difference(expr * arg1, expr * arg2, expr_ref &
br_status array_rewriter::mk_set_subset(expr * arg1, expr * arg2, expr_ref & result) {
mk_set_difference(arg1, arg2, result);
result = m().mk_eq(result.get(), m_util.mk_empty_set(m().get_sort(arg1)));
result = m().mk_eq(result.get(), m_util.mk_empty_set(arg1->get_sort()));
return BR_REWRITE3;
}
@ -654,7 +654,7 @@ bool array_rewriter::is_expandable_store(expr* s) {
}
expr_ref array_rewriter::expand_store(expr* s) {
sort* srt = m().get_sort(s);
sort* srt = s->get_sort();
unsigned arity = get_array_arity(srt);
ptr_vector<app> stores;
expr_ref result(m()), tmp(m());
@ -784,7 +784,7 @@ br_status array_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & result)
return false;
};
if (m_util.is_const(lhs1, v) && m_util.is_const(rhs1, w) &&
has_large_domain(m().get_sort(lhs), std::max(num_lhs, num_rhs))) {
has_large_domain(lhs->get_sort(), std::max(num_lhs, num_rhs))) {
mk_eq(lhs, lhs, rhs, fmls);
mk_eq(rhs, lhs, rhs, fmls);
fmls.push_back(m().mk_eq(v, w));

2
src/ast/rewriter/expr_safe_replace.cpp
View file

@ -99,7 +99,7 @@ void expr_safe_replace::operator()(expr* e, expr_ref& res) {
if (d) {
m_args.push_back(d);
arg_differs |= arg != d;
SASSERT(m.get_sort(arg) == m.get_sort(d));
SASSERT(arg->get_sort() == m.get_sort(d));
}
else {
m_todo.push_back(arg);

8
src/ast/rewriter/factor_rewriter.cpp
View file

@ -60,7 +60,7 @@ br_status factor_rewriter::mk_eq(expr * arg1, expr * arg2, expr_ref & result) {
expr_ref_vector eqs(m());
for(; it != end; ++it) {
expr* e = it->m_key;
eqs.push_back(m().mk_eq(e, a().mk_numeral(rational(0), m().get_sort(e))));
eqs.push_back(m().mk_eq(e, a().mk_numeral(rational(0), e->get_sort())));
}
result = m().mk_or(eqs.size(), eqs.c_ptr());
return BR_DONE;
@ -126,7 +126,7 @@ void factor_rewriter::mk_is_negative(expr_ref& result, expr_ref_vector& eqs) {
SASSERT(it != end);
expr_ref neg0(m()), neg(m()), pos0(m()), pos(m()), tmp(m());
expr* e = it->m_key;
expr_ref zero(a().mk_numeral(rational(0), m().get_sort(e)), m());
expr_ref zero(a().mk_numeral(rational(0), e->get_sort()), m());
expr_ref_vector conjs(m());
pos0 = m().mk_true();
neg0 = m().mk_false();
@ -257,7 +257,7 @@ bool factor_rewriter::extract_factors() {
m_factors.append(m_muls[0].size(), m_muls[0].c_ptr());
if (!m_adds[0].second) {
bool found_numeral = false;
sort* s = m().get_sort(m_muls[0][0]);
sort* s = m_muls[0][0]->get_sort();
rational v;
for (unsigned i = 0; !found_numeral && i < m_factors.size(); ++i) {
if (a().is_numeral(m_factors[i].get(), v)) {
@ -301,7 +301,7 @@ bool factor_rewriter::extract_factors() {
}
SASSERT(m_muls.size() == m_adds.size());
expr_ref_vector trail(m());
sort* s = m().get_sort(m_factors[0].get());
sort* s = m_factors[0]->get_sort();
for (unsigned i = 0; i < m_adds.size(); ++i) {
switch(m_muls[i].size()) {
case 0:

6
src/ast/rewriter/fpa_rewriter.cpp
View file

@ -313,12 +313,12 @@ br_status fpa_rewriter::mk_neg(expr * arg1, expr_ref & result) {
}
if (m_util.is_pinf(arg1)) {
// - +oo --> -oo
result = m_util.mk_ninf(m().get_sort(arg1));
result = m_util.mk_ninf(arg1->get_sort());
return BR_DONE;
}
if (m_util.is_ninf(arg1)) {
// - -oo -> +oo
result = m_util.mk_pinf(m().get_sort(arg1));
result = m_util.mk_pinf(arg1->get_sort());
return BR_DONE;
}
if (m_util.is_neg(arg1)) {
@ -476,7 +476,7 @@ br_status fpa_rewriter::mk_float_eq(expr * arg1, expr * arg2, expr_ref & result)
// Return (= arg NaN)
app * fpa_rewriter::mk_eq_nan(expr * arg) {
return m().mk_eq(arg, m_util.mk_nan(m().get_sort(arg)));
return m().mk_eq(arg, m_util.mk_nan(arg->get_sort()));
}
// Return (not (= arg NaN))

2
src/ast/rewriter/func_decl_replace.cpp
View file

@ -43,7 +43,7 @@ expr_ref func_decl_replace::operator()(expr* e) {
if (m_cache.find(arg, d)) {
m_args.push_back(d);
arg_differs |= arg != d;
SASSERT(m.get_sort(arg) == m.get_sort(d));
SASSERT(arg->get_sort() == m.get_sort(d));
}
else {
m_todo.push_back(arg);

2
src/ast/rewriter/inj_axiom.cpp
View file

@ -112,7 +112,7 @@ bool simplify_inj_axiom(ast_manager & m, quantifier * q, expr_ref & result) {
ptr_vector<sort> domain;
inv_vars.push_back(f);
for (unsigned i = 0; i < inv_vars.size(); ++i) {
domain.push_back(m.get_sort(inv_vars[i]));
domain.push_back(inv_vars[i]->get_sort());
}
sort * d = decl->get_domain(idx);
func_decl * inv_decl = m.mk_fresh_func_decl("inj", domain.size(), domain.c_ptr(), d);

2
src/ast/rewriter/mk_extract_proc.cpp
View file

@ -33,7 +33,7 @@ mk_extract_proc::~mk_extract_proc() {
app * mk_extract_proc::operator()(unsigned high, unsigned low, expr * arg) {
ast_manager & m = m_util.get_manager();
sort * s = m.get_sort(arg);
sort * s = arg->get_sort();
if (m_low == low && m_high == high && m_domain == s)
return m.mk_app(m_f_cached, arg);
// m_f_cached has a reference to m_domain, so, I don't need to inc_ref m_domain

2
src/ast/rewriter/mk_simplified_app.cpp
View file

@ -53,7 +53,7 @@ struct mk_simplified_app::imp {
if (k == OP_EQ) {
// theory dispatch for =
SASSERT(num == 2);
family_id s_fid = m.get_sort(args[0])->get_family_id();
family_id s_fid = args[0]->get_sort()->get_family_id();
if (s_fid == m_a_rw.get_fid())
st = m_a_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_bv_rw.get_fid())

4
src/ast/rewriter/poly_rewriter.h
View file

@ -133,7 +133,7 @@ public:
result = args[0];
return BR_DONE;
}
set_curr_sort(m().get_sort(args[0]));
set_curr_sort(args[0]->get_sort());
return m_flat ?
mk_flat_mul_core(num_args, args, result) :
mk_nflat_mul_core(num_args, args, result);
@ -144,7 +144,7 @@ public:
result = args[0];
return BR_DONE;
}
set_curr_sort(m().get_sort(args[0]));
set_curr_sort(args[0]->get_sort());
return m_flat ?
mk_flat_add_core(num_args, args, result) :
mk_nflat_add_core(num_args, args, result);

12
src/ast/rewriter/poly_rewriter_def.h
View file

@ -85,7 +85,7 @@ expr * poly_rewriter<Config>::mk_mul_app(unsigned num_args, expr * const * args)
return args[0];
default:
if (use_power()) {
sort* s = m().get_sort(args[0]);
sort* s = args[0]->get_sort();
rational k_prev;
expr * prev = get_power_body(args[0], k_prev);
rational k;
@ -668,7 +668,7 @@ br_status poly_rewriter<Config>::mk_nflat_add_core(unsigned num_args, expr * con
template<typename Config>
br_status poly_rewriter<Config>::mk_uminus(expr * arg, expr_ref & result) {
numeral a;
set_curr_sort(m().get_sort(arg));
set_curr_sort(arg->get_sort());
if (is_numeral(arg, a)) {
a.neg();
normalize(a);
@ -688,7 +688,7 @@ br_status poly_rewriter<Config>::mk_sub(unsigned num_args, expr * const * args,
result = args[0];
return BR_DONE;
}
set_curr_sort(m().get_sort(args[0]));
set_curr_sort(args[0]->get_sort());
expr_ref minus_one(mk_numeral(numeral(-1)), m());
expr_ref_buffer new_args(m());
new_args.push_back(args[0]);
@ -708,7 +708,7 @@ br_status poly_rewriter<Config>::mk_sub(unsigned num_args, expr * const * args,
*/
template<typename Config>
br_status poly_rewriter<Config>::cancel_monomials(expr * lhs, expr * rhs, bool move, expr_ref & lhs_result, expr_ref & rhs_result) {
set_curr_sort(m().get_sort(lhs));
set_curr_sort(lhs->get_sort());
mon_lt lt(*this);
unsigned lhs_sz;
expr * const * lhs_monomials = get_monomials(lhs, lhs_sz);
@ -921,7 +921,7 @@ bool poly_rewriter<Config>::hoist_multiplication(expr_ref& som) {
continue;
}
if (mul_map.find(e, j) && valid[j] && j != k) {
m_curr_sort = m().get_sort(adds[k]);
m_curr_sort = adds[k]->get_sort();
adds[j] = merge_muls(adds[j], adds[k]);
adds[k] = mk_numeral(rational(0));
valid[j] = false;
@ -964,7 +964,7 @@ expr* poly_rewriter<Config>::merge_muls(expr* x, expr* y) {
++k;
}
}
m_curr_sort = m().get_sort(x);
m_curr_sort = x->get_sort();
SASSERT(k > 0);
SASSERT(m1.size() >= k);
SASSERT(m2.size() >= k);

4
src/ast/rewriter/quant_hoist.cpp
View file

@ -113,9 +113,9 @@ public:
bound_names.push_back(v->get_decl()->get_name());
}
if (sorts) {
bound_sorts.push_back(m.get_sort(v));
bound_sorts.push_back(v->get_sort());
}
rep.insert(v, m.mk_var(index++, m.get_sort(v)));
rep.insert(v, m.mk_var(index++, v->get_sort()));
}
if (names && !bound_names.empty()) {
bound_names.reverse();

18
src/ast/rewriter/rewriter_def.h
View file

@ -90,10 +90,10 @@ bool rewriter_tpl<Config>::process_const(app * t0) {
if (m_pr) tout << mk_bounded_pp(m_pr, m()) << "\n";
);
CTRACE("reduce_app",
st != BR_FAILED && m().get_sort(m_r) != m().get_sort(t),
tout << mk_pp(m().get_sort(t), m()) << ": " << mk_pp(t, m()) << "\n";
st != BR_FAILED && m().get_sort(m_r) != t->get_sort(),
tout << mk_pp(t->get_sort(), m()) << ": " << mk_pp(t, m()) << "\n";
tout << m_r->get_id() << " " << mk_pp(m().get_sort(m_r), m()) << ": " << m_r << "\n";);
SASSERT(st != BR_DONE || m().get_sort(m_r) == m().get_sort(t));
SASSERT(st != BR_DONE || m().get_sort(m_r) == t->get_sort());
switch (st) {
case BR_FAILED:
if (!retried) {
@ -144,7 +144,7 @@ bool rewriter_tpl<Config>::visit(expr * t, unsigned max_depth) {
proof * new_t_pr = nullptr;
if (m_cfg.get_subst(t, new_t, new_t_pr)) {
TRACE("rewriter_subst", tout << "subst\n" << mk_ismt2_pp(t, m()) << "\n---->\n" << mk_ismt2_pp(new_t, m()) << "\n";);
SASSERT(m().get_sort(t) == m().get_sort(new_t));
SASSERT(t->get_sort() == m().get_sort(new_t));
result_stack().push_back(new_t);
set_new_child_flag(t, new_t);
SASSERT(rewrites_from(t, new_t_pr));
@ -171,7 +171,7 @@ bool rewriter_tpl<Config>::visit(expr * t, unsigned max_depth) {
#endif
expr * r = get_cached(t);
if (r) {
SASSERT(m().get_sort(r) == m().get_sort(t));
SASSERT(m().get_sort(r) == t->get_sort());
result_stack().push_back(r);
set_new_child_flag(t, r);
if (ProofGen) {
@ -312,10 +312,10 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
);
SASSERT(st == BR_FAILED || rewrites_to(m_r, m_pr2));
SASSERT(st == BR_FAILED || rewrites_from(new_t, m_pr2));
SASSERT(st != BR_DONE || m().get_sort(m_r) == m().get_sort(t));
SASSERT(st != BR_DONE || m().get_sort(m_r) == t->get_sort());
if (st != BR_FAILED) {
result_stack().shrink(fr.m_spos);
SASSERT(m().get_sort(m_r) == m().get_sort(t));
SASSERT(m().get_sort(m_r) == t->get_sort());
result_stack().push_back(m_r);
if (ProofGen) {
result_pr_stack().shrink(fr.m_spos);
@ -393,7 +393,7 @@ void rewriter_tpl<Config>::process_app(app * t, frame & fr) {
if (get_macro(f, def, def_pr)) {
SASSERT(!f->is_associative() || !flat_assoc(f));
SASSERT(new_num_args == t->get_num_args());
SASSERT(m().get_sort(def) == m().get_sort(t));
SASSERT(m().get_sort(def) == t->get_sort());
if (is_ground(def) && !m_cfg.reduce_macro()) {
m_r = def;
if (ProofGen) {
@ -759,7 +759,7 @@ void rewriter_tpl<Config>::resume_core(expr_ref & result, proof_ref & result_pr)
if (first_visit(fr) && fr.m_cache_result) {
expr * r = get_cached(t);
if (r) {
SASSERT(m().get_sort(r) == m().get_sort(t));
SASSERT(m().get_sort(r) == t->get_sort());
result_stack().push_back(r);
if (ProofGen) {
proof * pr = get_cached_pr(t);

102
src/ast/rewriter/seq_rewriter.cpp
View file

@ -47,8 +47,8 @@ expr_ref sym_expr::accept(expr* e) {
result = m.mk_not(result);
break;
case t_char:
SASSERT(m.get_sort(e) == m.get_sort(m_t));
SASSERT(m.get_sort(e) == m_sort);
SASSERT(e->get_sort() == m.get_sort(m_t));
SASSERT(e->get_sort() == m_sort);
result = m.mk_eq(e, m_t);
break;
case t_range:
@ -214,7 +214,7 @@ public:
if (x->is_not() && x->get_arg()->is_range() && u.is_const_char(x->get_arg()->get_lo(), lo) && 0 < lo) {
return l_true;
}
if (!m_var || m.get_sort(m_var) != x->get_sort()) {
if (!m_var || m_var->get_sort() != x->get_sort()) {
m_var = m.mk_fresh_const("x", x->get_sort());
}
expr_ref fml = x->accept(m_var);
@ -345,7 +345,7 @@ eautomaton* re2automaton::re2aut(expr* e) {
else if (u.re.is_full_seq(e)) {
expr_ref tt(m.mk_true(), m);
sort *seq_s = nullptr, *char_s = nullptr;
VERIFY (u.is_re(m.get_sort(e), seq_s));
VERIFY (u.is_re(e->get_sort(), seq_s));
VERIFY (u.is_seq(seq_s, char_s));
sym_expr* _true = sym_expr::mk_pred(tt, char_s);
return eautomaton::mk_loop(sm, _true);
@ -353,7 +353,7 @@ eautomaton* re2automaton::re2aut(expr* e) {
else if (u.re.is_full_char(e)) {
expr_ref tt(m.mk_true(), m);
sort *seq_s = nullptr, *char_s = nullptr;
VERIFY (u.is_re(m.get_sort(e), seq_s));
VERIFY (u.is_re(e->get_sort(), seq_s));
VERIFY (u.is_seq(seq_s, char_s));
sym_expr* _true = sym_expr::mk_pred(tt, char_s);
a = alloc(eautomaton, sm, _true);
@ -887,7 +887,7 @@ br_status seq_rewriter::lift_ites_throttled(func_decl* f, unsigned n, expr* cons
bool seq_rewriter::lift_ites_filter(func_decl* f, expr* ite) {
// do not lift ites from sequences over regexes
// for example DO NOT lift to_re(ite(c, s, t)) to ite(c, to_re(s), to_re(t))
if (u().is_re(f->get_range()) && u().is_seq(m().get_sort(ite)))
if (u().is_re(f->get_range()) && u().is_seq(ite->get_sort()))
return false;
// The following check is intended to avoid lifting cases such as
// substring(s,0,ite(c,e1,e2)) ==> ite(c, substring(s,0,e1), substring(s,0,e2))
@ -967,7 +967,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
bool constantPos = m_autil.is_numeral(b, pos);
bool constantLen = m_autil.is_numeral(c, len);
bool lengthPos = str().is_length(b) || m_autil.is_add(b);
sort* a_sort = m().get_sort(a);
sort* a_sort = a->get_sort();
sign sg;
if (sign_is_determined(c, sg) && sg == sign_neg) {
@ -1009,7 +1009,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
expr_ref_vector as(m()), bs(m());
str().get_concat_units(a, as);
if (as.empty()) {
result = str().mk_empty(m().get_sort(a));
result = str().mk_empty(a->get_sort());
return BR_DONE;
}
@ -1039,7 +1039,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
}
if (i == 0) return BR_FAILED;
expr_ref t1(m()), t2(m());
t1 = str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, m().get_sort(a));
t1 = str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, a->get_sort());
t2 = m_autil.mk_int(pos);
for (expr* rhs : lens) {
t2 = m_autil.mk_add(t2, str().mk_length(rhs));
@ -1080,10 +1080,10 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
std::function<bool(expr*)> is_unit = [&](expr *e) { return str().is_unit(e); };
if (_pos == 0 && as.forall(is_unit)) {
result = str().mk_empty(m().get_sort(a));
result = str().mk_empty(a->get_sort());
for (unsigned i = 1; i <= as.size(); ++i) {
result = m().mk_ite(m_autil.mk_ge(c, m_autil.mk_int(i)),
str().mk_concat(i, as.c_ptr(), m().get_sort(a)),
str().mk_concat(i, as.c_ptr(), a->get_sort()),
result);
}
return BR_REWRITE_FULL;
@ -1093,7 +1093,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
}
// (extract (++ (unit x) (unit y)) 3 c) = empty
if (offset == as.size()) {
result = str().mk_empty(m().get_sort(a));
result = str().mk_empty(a->get_sort());
return BR_DONE;
}
SASSERT(offset != 0 || _pos == 0);
@ -1104,11 +1104,11 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
unsigned i = offset;
for (; i < as.size() && str().is_unit(as.get(i)) && i - offset < _len; ++i);
if (i - offset == _len) {
result = str().mk_concat(_len, as.c_ptr() + offset, m().get_sort(a));
result = str().mk_concat(_len, as.c_ptr() + offset, a->get_sort());
return BR_DONE;
}
if (i == as.size()) {
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, m().get_sort(as.get(0)));
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, as[0]->get_sort());
return BR_DONE;
}
}
@ -1117,7 +1117,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
}
expr_ref pos1(m());
pos1 = m_autil.mk_sub(b, m_autil.mk_int(offset));
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, m().get_sort(as.get(0)));
result = str().mk_concat(as.size() - offset, as.c_ptr() + offset, as[0]->get_sort());
result = str().mk_substr(result, pos1, c);
return BR_REWRITE3;
}
@ -1246,7 +1246,7 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) {
}
if (offs > 0 || sz < as.size()) {
SASSERT(sz > offs);
result = str().mk_contains(str().mk_concat(sz-offs, as.c_ptr()+offs, m().get_sort(a)), b);
result = str().mk_contains(str().mk_concat(sz-offs, as.c_ptr()+offs, a->get_sort()), b);
return BR_REWRITE2;
}
@ -1285,7 +1285,7 @@ br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) {
zstring c;
rational r;
expr_ref_vector lens(m());
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
if (!get_lengths(b, lens, r)) {
return BR_FAILED;
}
@ -1309,7 +1309,7 @@ br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) {
str().get_concat_units(a, m_lhs);
if (m_lhs.empty()) {
result = str().mk_empty(m().get_sort(a));
result = str().mk_empty(a->get_sort());
return BR_DONE;
}
@ -1441,7 +1441,7 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result
rational r;
bool isc1 = str().is_string(a, s1);
bool isc2 = str().is_string(b, s2);
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
if (isc1 && isc2 && m_autil.is_numeral(c, r) && r.is_unsigned()) {
int idx = s1.indexofu(s2, r.get_unsigned());
@ -1534,7 +1534,7 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result
break;
}
if (is_zero && !as.empty() && str().is_unit(as.get(0))) {
expr_ref a1(str().mk_concat(as.size() - 1, as.c_ptr() + 1, m().get_sort(as.get(0))), m());
expr_ref a1(str().mk_concat(as.size() - 1, as.c_ptr() + 1, as[0]->get_sort()), m());
expr_ref b1(str().mk_index(a1, b, c), m());
result = m().mk_ite(str().mk_prefix(b, a), zero(),
m().mk_ite(m_autil.mk_ge(b1, zero()), m_autil.mk_add(one(), b1), minus_one()));
@ -1589,7 +1589,7 @@ seq_rewriter::length_comparison seq_rewriter::compare_lengths(unsigned sza, expr
br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& result) {
zstring s1, s2, s3;
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
if (str().is_string(a, s1) && str().is_string(b, s2) &&
str().is_string(c, s3)) {
result = str().mk_string(s1.replace(s2, s3));
@ -1701,7 +1701,7 @@ br_status seq_rewriter::mk_seq_replace_all(expr* a, expr* b, expr* c, expr_ref&
return BR_DONE;
}
if (a == b) {
result = m().mk_ite(str().mk_is_empty(b), str().mk_empty(m().get_sort(a)), c);
result = m().mk_ite(str().mk_is_empty(b), str().mk_empty(a->get_sort()), c);
return BR_REWRITE1;
}
zstring s1, s2;
@ -1721,7 +1721,7 @@ br_status seq_rewriter::mk_seq_replace_all(expr* a, expr* b, expr* c, expr_ref&
else
strs.push_back(str().mk_unit(str().mk_char(s1, i)));
}
result = str().mk_concat(strs, m().get_sort(a));
result = str().mk_concat(strs, a->get_sort());
return BR_REWRITE_FULL;
}
return BR_FAILED;
@ -1741,7 +1741,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) {
zstring s1, s2;
bool isc1 = str().is_string(a, s1);
bool isc2 = str().is_string(b, s2);
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
if (isc1 && isc2) {
result = m().mk_bool_val(s1.prefixof(s2));
TRACE("seq", tout << result << "\n";);
@ -1856,7 +1856,7 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) {
result = m().mk_true();
return BR_DONE;
}
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
if (str().is_empty(a)) {
result = m().mk_true();
return BR_DONE;
@ -2075,7 +2075,7 @@ br_status seq_rewriter::mk_str_stoi(expr* a, expr_ref& result) {
// if tail < 0 then tail else
// if stoi(head) >= 0 and then stoi(head)*10+tail else -1
expr_ref tail(str().mk_stoi(as.back()), m());
expr_ref head(str().mk_concat(as.size() - 1, as.c_ptr(), m().get_sort(a)), m());
expr_ref head(str().mk_concat(as.size() - 1, as.c_ptr(), a->get_sort()), m());
expr_ref stoi_head(str().mk_stoi(head), m());
result = m().mk_ite(m_autil.mk_ge(stoi_head, m_autil.mk_int(0)),
m_autil.mk_add(m_autil.mk_mul(m_autil.mk_int(10), stoi_head), tail),
@ -2184,7 +2184,7 @@ bool seq_rewriter::get_head_tail(expr* s, expr_ref& head, expr_ref& tail) {
zstring s1;
if (str().is_unit(s, h)) {
head = h;
tail = str().mk_empty(m().get_sort(s));
tail = str().mk_empty(s->get_sort());
return true;
}
if (str().is_string(s, s1) && s1.length() > 0) {
@ -2206,7 +2206,7 @@ bool seq_rewriter::get_head_tail_reversed(expr* s, expr_ref& head, expr_ref& tai
expr* h = nullptr, *t = nullptr;
zstring s1;
if (str().is_unit(s, t)) {
head = str().mk_empty(m().get_sort(s));
head = str().mk_empty(s->get_sort());
tail = t;
return true;
}
@ -2254,7 +2254,7 @@ expr_ref seq_rewriter::re_and(expr* cond, expr* r) {
expr_ref _cond(cond, m()), _r(r, m());
if (m().is_true(cond))
return expr_ref(r, m());
expr* re_empty = re().mk_empty(m().get_sort(r));
expr* re_empty = re().mk_empty(r->get_sort());
if (m().is_false(cond))
return expr_ref(re_empty, m());
return expr_ref(m().mk_ite(cond, r, re_empty), m());
@ -2341,7 +2341,7 @@ expr_ref seq_rewriter::is_nullable_rec(expr* r) {
}
else {
SASSERT(m_util.is_seq(r));
result = m().mk_eq(str().mk_empty(m().get_sort(r)), r);
result = m().mk_eq(str().mk_empty(r->get_sort()), r);
}
return result;
}
@ -2961,7 +2961,7 @@ expr_ref seq_rewriter::mk_derivative_rec(expr* ele, expr* r) {
VERIFY(m_util.is_seq(seq_sort, ele_sort));
SASSERT(ele_sort == m().get_sort(ele));
expr* r1 = nullptr, *r2 = nullptr, *p = nullptr;
auto mk_empty = [&]() { return expr_ref(re().mk_empty(m().get_sort(r)), m()); };
auto mk_empty = [&]() { return expr_ref(re().mk_empty(r->get_sort()), m()); };
unsigned lo = 0, hi = 0;
if (re().is_concat(r, r1, r2)) {
expr_ref is_n = is_nullable(r1);
@ -3245,7 +3245,7 @@ bool seq_rewriter::rewrite_contains_pattern(expr* a, expr* b, expr_ref& result)
return false;
expr_ref_vector fmls(m());
sort* rs = m().get_sort(b);
sort* rs = b->get_sort();
expr_ref full(re().mk_full_seq(rs), m()), prefix(m()), suffix(m());
fmls.push_back(re().mk_in_re(y, b));
prefix = full;
@ -3376,7 +3376,7 @@ br_status seq_rewriter::mk_str_in_regexp(expr* a, expr* b, expr_ref& result) {
for (unsigned i = 0; i < len; ++i) {
args.push_back(str().mk_unit(str().mk_nth_i(a, m_autil.mk_int(i))));
}
expr_ref in_re(re().mk_in_re(str().mk_concat(args, m().get_sort(a)), b), m());
expr_ref in_re(re().mk_in_re(str().mk_concat(args, a->get_sort()), b), m());
result = m().mk_and(len_lim, in_re);
return BR_REWRITE_FULL;
}
@ -3596,7 +3596,7 @@ br_status seq_rewriter::mk_re_union(expr* a, expr* b, expr_ref& result) {
br_status st = mk_re_union0(a, b, result);
if (st != BR_FAILED)
return st;
auto mk_full = [&]() { return re().mk_full_seq(m().get_sort(a)); };
auto mk_full = [&]() { return re().mk_full_seq(a->get_sort()); };
if (are_complements(a, b)) {
result = mk_full();
return BR_DONE;
@ -3665,11 +3665,11 @@ br_status seq_rewriter::mk_re_complement(expr* a, expr_ref& result) {
return BR_REWRITE2;
}
if (re().is_empty(a)) {
result = re().mk_full_seq(m().get_sort(a));
result = re().mk_full_seq(a->get_sort());
return BR_DONE;
}
if (re().is_full_seq(a)) {
result = re().mk_empty(m().get_sort(a));
result = re().mk_empty(a->get_sort());
return BR_DONE;
}
if (re().is_complement(a, e1)) {
@ -3719,7 +3719,7 @@ br_status seq_rewriter::mk_re_inter(expr* a, expr* b, expr_ref& result) {
br_status st = mk_re_inter0(a, b, result);
if (st != BR_FAILED)
return st;
auto mk_empty = [&]() { return re().mk_empty(m().get_sort(a)); };
auto mk_empty = [&]() { return re().mk_empty(a->get_sort()); };
if (are_complements(a, b)) {
result = mk_empty();
return BR_DONE;
@ -3770,7 +3770,7 @@ br_status seq_rewriter::mk_re_inter(expr* a, expr* b, expr_ref& result) {
std::swap(a, b);
expr* s = nullptr;
if (re().is_to_re(a, s)) {
result = m().mk_ite(re().mk_in_re(s, b), a, re().mk_empty(m().get_sort(a)));
result = m().mk_ite(re().mk_in_re(s, b), a, re().mk_empty(a->get_sort()));
return BR_REWRITE2;
}
return BR_FAILED;
@ -3793,11 +3793,11 @@ br_status seq_rewriter::mk_re_loop(func_decl* f, unsigned num_args, expr* const*
hi2 = np > 1 ? f->get_parameter(1).get_int() : lo2;
// (loop a 0 0) = ""
if (np == 2 && lo2 > hi2) {
result = re().mk_empty(m().get_sort(args[0]));
result = re().mk_empty(args[0]->get_sort());
return BR_DONE;
}
if (np == 2 && hi2 == 0) {
result = re().mk_to_re(str().mk_empty(re().to_seq(m().get_sort(args[0]))));
result = re().mk_to_re(str().mk_empty(re().to_seq(args[0]->get_sort())));
return BR_DONE;
}
// (loop (loop a lo) lo2) = (loop lo*lo2)
@ -3863,7 +3863,7 @@ br_status seq_rewriter::mk_re_star(expr* a, expr_ref& result) {
return BR_DONE;
}
if (re().is_full_char(a)) {
result = re().mk_full_seq(m().get_sort(a));
result = re().mk_full_seq(a->get_sort());
return BR_DONE;
}
if (re().is_empty(a)) {
@ -3902,7 +3902,7 @@ br_status seq_rewriter::mk_re_star(expr* a, expr_ref& result) {
if (m().is_ite(a, c, b1, c1)) {
if ((re().is_full_char(b1) || re().is_full_seq(b1)) &&
(re().is_full_char(c1) || re().is_full_seq(c1))) {
result = re().mk_full_seq(m().get_sort(b1));
result = re().mk_full_seq(b1->get_sort());
return BR_REWRITE2;
}
@ -4077,7 +4077,7 @@ br_status seq_rewriter::reduce_re_is_empty(expr* r, expr_ref& result) {
expr* r1, *r2, *r3, *r4;
zstring s1, s2;
unsigned lo, hi;
auto eq_empty = [&](expr* r) { return m().mk_eq(r, re().mk_empty(m().get_sort(r))); };
auto eq_empty = [&](expr* r) { return m().mk_eq(r, re().mk_empty(r->get_sort())); };
if (re().is_union(r, r1, r2)) {
result = m().mk_and(eq_empty(r1), eq_empty(r2));
return BR_REWRITE2;
@ -4214,7 +4214,7 @@ bool seq_rewriter::reduce_back(expr_ref_vector& ls, expr_ref_vector& rs, expr_re
SASSERT(s.length() > 0);
app_ref ch(str().mk_char(s, s.length()-1), m());
SASSERT(m().get_sort(ch) == m().get_sort(a));
SASSERT(m().get_sort(ch) == a->get_sort());
new_eqs.push_back(ch, a);
ls.pop_back();
if (s.length() == 1) {
@ -4281,7 +4281,7 @@ bool seq_rewriter::reduce_front(expr_ref_vector& ls, expr_ref_vector& rs, expr_r
else if (str().is_unit(l, a) && str().is_string(r, s)) {
SASSERT(s.length() > 0);
app* ch = str().mk_char(s, 0);
SASSERT(m().get_sort(ch) == m().get_sort(a));
SASSERT(m().get_sort(ch) == a->get_sort());
new_eqs.push_back(ch, a);
++head1;
if (s.length() == 1) {
@ -4375,7 +4375,7 @@ bool seq_rewriter::reduce_eq(expr* l, expr* r, expr_ref_pair_vector& new_eqs, bo
void seq_rewriter::add_seqs(expr_ref_vector const& ls, expr_ref_vector const& rs, expr_ref_pair_vector& eqs) {
if (!ls.empty() || !rs.empty()) {
sort * s = m().get_sort(ls.empty() ? rs[0] : ls[0]);
sort * s = (ls.empty() ? rs[0] : ls[0])->get_sort();
eqs.push_back(str().mk_concat(ls, s), str().mk_concat(rs, s));
}
}
@ -4385,7 +4385,7 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
m_lhs.reset();
str().get_concat(a, m_lhs);
TRACE("seq", tout << expr_ref(a, m()) << " " << expr_ref(b, m()) << "\n";);
sort* sort_a = m().get_sort(a);
sort* sort_a = a->get_sort();
zstring s;
for (unsigned i = 0; i < m_lhs.size(); ++i) {
expr* e = m_lhs.get(i);
@ -4411,7 +4411,7 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
}
if (str().is_string(b, s)) {
expr* all = re().mk_full_seq(re().mk_re(m().get_sort(b)));
expr* all = re().mk_full_seq(re().mk_re(b->get_sort()));
disj.push_back(re().mk_in_re(str().mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i, sort_a),
re().mk_concat(all, re().mk_concat(re().mk_to_re(b), all))));
return true;
@ -4429,7 +4429,7 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) {
expr* seq_rewriter::concat_non_empty(expr_ref_vector& es) {
sort* s = m().get_sort(es.get(0));
sort* s = es[0]->get_sort();
unsigned j = 0;
for (expr* e : es) {
if (str().is_unit(e) || str().is_string(e))
@ -4462,7 +4462,7 @@ bool seq_rewriter::set_empty(unsigned sz, expr* const* es, bool all, expr_ref_pa
}
}
else {
emp = emp?emp:str().mk_empty(m().get_sort(es[i]));
emp = emp?emp:str().mk_empty(es[i]->get_sort());
eqs.push_back(emp, es[i]);
}
}
@ -4652,7 +4652,7 @@ bool seq_rewriter::reduce_subsequence(expr_ref_vector& ls, expr_ref_vector& rs,
rs.shrink(j);
SASSERT(ls.size() == rs.size());
if (!ls.empty()) {
sort* srt = m().get_sort(ls.get(0));
sort* srt = ls[0]->get_sort();
eqs.push_back(str().mk_concat(ls, srt),
str().mk_concat(rs, srt));
ls.reset();

4
src/ast/rewriter/seq_rewriter.h
View file

@ -55,10 +55,10 @@ class sym_expr {
public:
~sym_expr() { if (m_expr) m_expr->dec_ref(); }
expr_ref accept(expr* e);
static sym_expr* mk_char(expr_ref& t) { return alloc(sym_expr, t_char, t, t, t.get_manager().get_sort(t), nullptr); }
static sym_expr* mk_char(expr_ref& t) { return alloc(sym_expr, t_char, t, t, t->get_sort(), nullptr); }
static sym_expr* mk_char(ast_manager& m, expr* t) { expr_ref tr(t, m); return mk_char(tr); }
static sym_expr* mk_pred(expr_ref& t, sort* s) { return alloc(sym_expr, t_pred, t, t, s, nullptr); }
static sym_expr* mk_range(expr_ref& lo, expr_ref& hi) { return alloc(sym_expr, t_range, lo, hi, lo.get_manager().get_sort(hi), nullptr); }
static sym_expr* mk_range(expr_ref& lo, expr_ref& hi) { return alloc(sym_expr, t_range, lo, hi, hi->get_sort(), nullptr); }
static sym_expr* mk_not(ast_manager& m, sym_expr* e) { expr_ref f(m); e->inc_ref(); return alloc(sym_expr, t_not, f, f, e->get_sort(), e); }
void inc_ref() { ++m_ref; }
void dec_ref() { --m_ref; if (m_ref == 0) dealloc(this); }

16
src/ast/rewriter/th_rewriter.cpp
View file

@ -175,7 +175,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
if (k == OP_EQ) {
// theory dispatch for =
SASSERT(num == 2);
family_id s_fid = m().get_sort(args[0])->get_family_id();
family_id s_fid = args[0]->get_sort()->get_family_id();
if (s_fid == m_a_rw.get_fid())
st = m_a_rw.mk_eq_core(args[0], args[1], result);
else if (s_fid == m_bv_rw.get_fid())
@ -199,7 +199,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
}
if (k == OP_ITE) {
SASSERT(num == 3);
family_id s_fid = m().get_sort(args[1])->get_family_id();
family_id s_fid = args[1]->get_sort()->get_family_id();
if (s_fid == m_bv_rw.get_fid())
st = m_bv_rw.mk_ite_core(args[0], args[1], args[2], result);
if (st != BR_FAILED)
@ -348,16 +348,16 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
family_id fid = t->get_family_id();
if (fid == m_a_rw.get_fid()) {
switch (t->get_decl_kind()) {
case OP_ADD: n = m_a_util.mk_numeral(rational::zero(), m().get_sort(t)); return true;
case OP_MUL: n = m_a_util.mk_numeral(rational::one(), m().get_sort(t)); return true;
case OP_ADD: n = m_a_util.mk_numeral(rational::zero(), t->get_sort()); return true;
case OP_MUL: n = m_a_util.mk_numeral(rational::one(), t->get_sort()); return true;
default:
return false;
}
}
if (fid == m_bv_rw.get_fid()) {
switch (t->get_decl_kind()) {
case OP_BADD: n = m_bv_util.mk_numeral(rational::zero(), m().get_sort(t)); return true;
case OP_BMUL: n = m_bv_util.mk_numeral(rational::one(), m().get_sort(t)); return true;
case OP_BADD: n = m_bv_util.mk_numeral(rational::zero(), t->get_sort()); return true;
case OP_BMUL: n = m_bv_util.mk_numeral(rational::one(), t->get_sort()); return true;
default:
return false;
}
@ -588,11 +588,11 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
decl_kind k = f->get_decl_kind();
if (k == OP_EQ) {
SASSERT(num == 2);
fid = m().get_sort(args[0])->get_family_id();
fid = args[0]->get_sort()->get_family_id();
}
else if (k == OP_ITE) {
SASSERT(num == 3);
fid = m().get_sort(args[1])->get_family_id();
fid = args[1]->get_sort()->get_family_id();
}
}
app_ref tmp(m());

2
src/ast/rewriter/value_sweep.cpp
View file

@ -69,7 +69,7 @@ bool value_sweep::assign_next_value() {
++m_vhead;
if (!get_value(v)) {
unsigned index = m_rand() % m_range;
expr_ref val = m_gen.get_value(m.get_sort(v), index);
expr_ref val = m_gen.get_value(v->get_sort(), index);
set_value_core(v, val);
m_queue.push_back(v);
return true;

12
src/ast/static_features.cpp
View file

@ -172,7 +172,7 @@ void static_features::update_core(expr * e) {
// even if a benchmark does not contain any theory interpreted function decls, we still have to install
// the theory if the benchmark contains constants or function applications of an interpreted sort.
sort * s = m.get_sort(e);
sort * s = e->get_sort();
if (!m.is_uninterp(s))
mark_theory(s->get_family_id());
@ -193,7 +193,7 @@ void static_features::update_core(expr * e) {
acc_num(arg);
// Must check whether arg is diff logic or not.
// Otherwise, problem can be incorrectly tagged as diff logic.
sort * arg_s = m.get_sort(arg);
sort * arg_s = arg->get_sort();
family_id fid_arg = arg_s->get_family_id();
if (fid_arg == m_afid) {
m_num_arith_terms++;
@ -263,7 +263,7 @@ void static_features::update_core(expr * e) {
if (!is_arith_expr(to_app(e)->get_arg(0)))
m_num_simple_eqs++;
}
sort * s = m.get_sort(to_app(e)->get_arg(0));
sort * s = to_app(e)->get_arg(0)->get_sort();
if (!m.is_uninterp(s)) {
family_id fid = s->get_family_id();
if (fid != null_family_id && fid != m_bfid)
@ -281,7 +281,7 @@ void static_features::update_core(expr * e) {
if (is_app(e) && to_app(e)->get_family_id() == m_srfid)
m_has_sr = true;
if (!m_has_arrays && m_arrayutil.is_array(e))
check_array(m.get_sort(e));
check_array(e->get_sort());
if (!m_has_ext_arrays && m_arrayutil.is_array(e) &&
!m_arrayutil.is_select(e) && !m_arrayutil.is_store(e))
m_has_ext_arrays = true;
@ -323,7 +323,7 @@ void static_features::update_core(expr * e) {
m_num_uninterpreted_exprs++;
if (to_app(e)->get_num_args() == 0) {
m_num_uninterpreted_constants++;
sort * s = m.get_sort(e);
sort * s = e->get_sort();
if (!m.is_uninterp(s)) {
family_id fid = s->get_family_id();
if (fid != null_family_id && fid != m_bfid)
@ -350,7 +350,7 @@ void static_features::update_core(expr * e) {
}
if (!_is_eq && !_is_gate) {
for (expr * arg : *to_app(e)) {
sort * arg_s = m.get_sort(arg);
sort * arg_s = arg->get_sort();
if (!m.is_uninterp(arg_s)) {
family_id fid_arg = arg_s->get_family_id();
if (fid_arg != fid && fid_arg != null_family_id) {

6
src/ast/substitution/substitution_tree.cpp
View file

@ -73,7 +73,7 @@ void substitution_tree::linearize(svector<subst> & result) {
for (unsigned i = 0; i < m_todo.size(); i++) {
unsigned ireg_idx = m_todo[i];
expr * n = get_reg_value(ireg_idx);
var * ireg = m_manager.mk_var(ireg_idx, m_manager.get_sort(n));
var * ireg = m_manager.mk_var(ireg_idx, n->get_sort());
if (is_var(n))
push(result, subst(ireg, n));
else {
@ -87,7 +87,7 @@ void substitution_tree::linearize(svector<subst> & result) {
unsigned oreg = next_reg();
set_reg_value(oreg, to_app(n)->get_arg(j));
m_todo.push_back(oreg);
sort * s = m_manager.get_sort(get_reg_value(oreg));
sort * s = get_reg_value(oreg)->get_sort();
new_args.push_back(m_manager.mk_var(oreg, s));
}
new_app = m_manager.mk_app(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr());
@ -731,7 +731,7 @@ template<substitution_tree::st_visit_mode Mode>
bool substitution_tree::visit_vars(expr * e, st_visitor & st) {
if (m_vars.empty())
return true; // continue
sort * s = m_manager.get_sort(e);
sort * s = e->get_sort();
unsigned s_id = s->get_decl_id();
if (s_id < m_vars.size()) {
var_ref_vector * v = m_vars[s_id];

2
src/ast/well_sorted.cpp
View file

@ -56,7 +56,7 @@ struct well_sorted_proc {
}
for (unsigned i = 0; i < num_args; i++) {
sort * actual_sort = m_manager.get_sort(n->get_arg(i));
sort * actual_sort = n->get_arg(i)->get_sort();
sort * expected_sort = decl->is_associative() ? decl->get_domain(0) : decl->get_domain(i);
if (expected_sort != actual_sort) {
TRACE("tc", tout << "sort mismatch on argument #" << i << ".\n" << mk_ismt2_pp(n, m_manager);