/*
Copyright (c) 2016 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.

Author: Leonardo de Moura
*/
#include <string>
#include <utility>
#include "runtime/thread.h"
#include "runtime/flet.h"
#include "util/option_declarations.h"
#include "kernel/find_fn.h"
#include "kernel/for_each_fn.h"
#include "kernel/abstract.h"
#include "kernel/replace_fn.h"
#include "kernel/instantiate.h"
#include "library/scope_pos_info_provider.h"
#include "library/error_msgs.h"
#include "library/trace.h"
#include "library/user_recursors.h"
#include "library/aux_recursors.h"
#include "library/app_builder.h"
#include "library/constants.h"
#include "library/suffixes.h"
#include "library/placeholder.h"
#include "library/explicit.h"
#include "library/string.h"
#include "library/class.h"
#include "library/sorry.h"
#include "library/util.h"
#include "library/annotation.h"
#include "library/pp_options.h"
#include "library/replace_visitor.h"
#include "library/locals.h"
#include "library/private.h"
#include "library/attribute_manager.h"
#include "library/protected.h"
#include "library/message_builder.h"
#include "library/aliases.h"
#include "library/aux_definition.h"
#include "library/check.h"
#include "library/compiler/compiler.h"
#include "library/tactic/kabstract.h"
#include "library/tactic/tactic_state.h"
#include "library/tactic/tactic_evaluator.h"
#include "library/equations_compiler/compiler.h"
#include "library/equations_compiler/util.h"
#include "frontends/lean/builtin_exprs.h"
#include "frontends/lean/brackets.h"
#include "frontends/lean/util.h"
#include "frontends/lean/prenum.h"
#include "frontends/lean/structure_cmd.h"
#include "frontends/lean/structure_instance.h"
#include "frontends/lean/elaborator.h"
#include "frontends/lean/typed_expr.h"
#include "frontends/lean/choice.h"

#ifndef LEAN_DEFAULT_ELABORATOR_COERCIONS
#define LEAN_DEFAULT_ELABORATOR_COERCIONS true
#endif

namespace lean {
static name * g_elab_strategy = nullptr;
static name * g_elaborator_coercions = nullptr;

bool get_elaborator_coercions(options const & opts) {
    return opts.get_bool(*g_elaborator_coercions, LEAN_DEFAULT_ELABORATOR_COERCIONS);
}

struct elaborator_strategy_attribute_data : public attr_data {
    elaborator_strategy m_status;
    elaborator_strategy_attribute_data() {}
    elaborator_strategy_attribute_data(elaborator_strategy status) : m_status(status) {}
    virtual unsigned hash() const override { return static_cast<unsigned>(m_status); }
    void write(serializer & s) const { s << static_cast<char>(m_status); }
    void read(deserializer & d) {
        char c; d >> c;
        m_status = static_cast<elaborator_strategy>(c);
    }
};

bool operator==(elaborator_strategy_attribute_data const & d1, elaborator_strategy_attribute_data const & d2) {
    return d1.m_status == d2.m_status;
}

template class typed_attribute<elaborator_strategy_attribute_data>;
typedef typed_attribute<elaborator_strategy_attribute_data> elaborator_strategy_attribute;

static elaborator_strategy_attribute const & get_elaborator_strategy_attribute() {
    return static_cast<elaborator_strategy_attribute const &>(get_system_attribute(*g_elab_strategy));
}

class elaborator_strategy_proxy_attribute : public proxy_attribute<elaborator_strategy_attribute_data> {
    typedef proxy_attribute<elaborator_strategy_attribute_data> parent;
public:
    elaborator_strategy_proxy_attribute(char const * id, char const * descr, elaborator_strategy status):
        parent(id, descr, status) {}

    virtual typed_attribute<elaborator_strategy_attribute_data> const & get_attribute() const {
        return get_elaborator_strategy_attribute();
    }
};

elaborator_strategy get_elaborator_strategy(environment const & env, name const & n) {
    if (auto data = get_elaborator_strategy_attribute().get(env, n))
        return data->m_status;

    if (is_recursor(env, n) ||
        is_aux_recursor(env, n)) {
        // is_user_defined_recursor(env, n)) {
        return elaborator_strategy::AsEliminator;
    }

    return elaborator_strategy::WithExpectedType;
}

#define trace_elab(CODE) lean_trace("elaborator", scope_trace_env _scope(m_env, m_ctx); CODE)
#define trace_elab_detail(CODE) lean_trace("elaborator_detail", scope_trace_env _scope(m_env, m_ctx); CODE)
#define trace_elab_debug(CODE) lean_trace("elaborator_debug", scope_trace_env _scope(m_env, m_ctx); CODE)
#define trace_elab_numeral(CODE) lean_trace(name({"elaborator", "numeral"}), scope_trace_env _scope(m_env, m_ctx); CODE)
#define trace_elab_instances(CODE) lean_trace(name({"elaborator", "instances"}), scope_trace_env _scope(m_env, m_ctx); CODE)
#define trace_elab_equation(CODE) lean_trace(name({"elaborator", "equation"}), scope_trace_env _scope(m_env, m_ctx); CODE)

elaborator::elaborator(environment const & env, options const & opts, name const & decl_name,
                       metavar_context const & mctx, local_context const & lctx, bool recover_from_errors,
                       bool in_pattern):
    m_env(env), m_opts(opts), m_cache(opts), m_decl_name(decl_name),
    m_ctx(env, mctx, lctx, m_cache, transparency_mode::Semireducible),
    m_recover_from_errors(recover_from_errors),
    m_uses_infom(false /* get_global_info_manager() != nullptr */),
    m_in_pattern(in_pattern) {
    m_coercions = get_elaborator_coercions(opts);
}

elaborator::~elaborator() {
}

auto elaborator::mk_pp_ctx() -> pp_fn {
    return ::lean::mk_pp_ctx(m_ctx.env(), m_opts, m_ctx.mctx(), m_ctx.lctx());
}

formatter elaborator::mk_fmt_ctx() {
    return formatter(m_opts, [=](expr const & e, options const & o) {
        return ::lean::mk_pp_ctx(m_ctx.env(), o, m_ctx.mctx(), m_ctx.lctx())(e);
    });
}

format elaborator::pp_indent(pp_fn const & pp_fn, expr const & e) {
    unsigned i = get_pp_indent(m_opts);
    return nest(i, line() + pp_fn(e));
}

format elaborator::pp_indent(expr const & e) {
    return pp_indent(mk_pp_ctx(), e);
}

format elaborator::pp(expr const & e) {
    auto fn = mk_pp_ctx();
    return fn(e);
}

format elaborator::pp_overload(pp_fn const & pp_fn, expr const & fn) {
    return is_constant(fn) ? format(const_name(fn)) : pp_fn(fn);
}

format elaborator::pp_overloads(pp_fn const & pp_fn, buffer<expr> const & fns) {
    format r("overloads:");
    r += space();
    bool first = true;
    for (expr const & fn : fns) {
        if (first) first = false; else r += format(", ");
        r += pp_overload(pp_fn, fn);
    }
    return paren(r);
}

format elaborator::pp_type_mismatch(expr const & e, expr const & e_type, expr const & expected_type) {
    try {
        expr e_type_type = instantiate_mvars(whnf(infer_type(e_type)));
        expr expected_type_type = instantiate_mvars(whnf(infer_type(expected_type)));
        return ::lean::pp_type_mismatch(mk_fmt_ctx(), e, e_type, expected_type, some_expr(e_type_type), some_expr(expected_type_type));
    } catch (exception &) {
        return ::lean::pp_type_mismatch(mk_fmt_ctx(), e, e_type, expected_type);
    }
}

format elaborator::pp_type_mismatch(expr const & e_type, expr const & expected_type) {
    try {
        expr e_type_type = instantiate_mvars(whnf(infer_type(e_type)));
        expr expected_type_type = instantiate_mvars(whnf(infer_type(expected_type)));
        return ::lean::pp_type_mismatch(mk_fmt_ctx(), e_type, expected_type, some_expr(e_type_type), some_expr(expected_type_type));
    } catch (exception &) {
        return ::lean::pp_type_mismatch(mk_fmt_ctx(), e_type, expected_type);
    }
}

bool elaborator::try_report(std::exception const & ex) {
    return try_report(ex, none_expr());
}

bool elaborator::try_report(std::exception const & ex, optional<expr> const & ref) {
    if (auto elab_ex = dynamic_cast<elaborator_exception const *>(&ex)) {
        if (elab_ex->is_ignored()) return true;
    }
    if (!m_recover_from_errors) return false;

    auto pip = get_pos_info_provider();
    if (!pip) return false;
    auto pos = pip->get_some_pos();
    if (m_last_pos)
        pos = *m_last_pos;
    if (ref)
        if (auto p = get_pos(*ref))
            pos = *p;

    auto tc = std::make_shared<type_context_old>(m_env, m_opts, m_ctx.mctx(), m_ctx.lctx());
    message_builder out(tc, m_env, get_global_ios(), pip->get_file_name(), pos, ERROR);
    out.set_exception(ex);
    out.report();
    m_has_errors = true;
    return true;
}

void elaborator::report_or_throw(elaborator_exception const & ex) {
    if (!try_report(ex))
        throw elaborator_exception(ex);
}

bool elaborator::has_synth_sorry(std::initializer_list<expr> && es) {
    for (auto & e : es) {
        if (has_synthetic_sorry(instantiate_mvars(e))) {
            return true;
        }
    }
    return false;
}

expr elaborator::mk_sorry(optional<expr> const & expected_type, expr const & ref, bool synthetic) {
    auto sorry_type = expected_type ? *expected_type : mk_type_metavar(ref);
    return mk_sorry(sorry_type, synthetic);
}

expr elaborator::recoverable_error(optional<expr> const & expected_type, expr const & ref, elaborator_exception const & ex) {
    report_or_throw(ex);
    return mk_sorry(expected_type, ref);
}


level elaborator::mk_univ_metavar() {
    return m_ctx.mk_univ_metavar_decl();
}

expr elaborator::mk_metavar(expr const & A, expr const & ref) {
    return mk_metavar(name(), A, ref);
}

expr elaborator::mk_metavar(name const & pp_n, expr const & A, expr const &) {
    auto m = m_ctx.mk_metavar_decl(pp_n.is_anonymous() ? pp_n : pp_n.append_before("?"), m_ctx.lctx(), A);
    m_user_mvars.insert(mk_pair(m, user_mvar_info(m_last_pos ? *m_last_pos : pos_info(1, 0))));
    return m;
}

expr elaborator::mk_metavar(optional<expr> const & A, expr const & ref) {
    if (A)
        return mk_metavar(*A, ref);
    else
        return mk_metavar(mk_type_metavar(ref), ref);
}

expr elaborator::mk_type_metavar(expr const & ref) {
    level l = mk_univ_metavar();
    return mk_metavar(mk_sort(l), ref);
}

expr elaborator::mk_instance_core(local_context const & lctx, expr const & C, expr const & ref) {
    scope_traces_as_messages traces_as_messages(get_pos_info_provider(), ref);

    // TODO(gabriel): cache failures so that we do not report errors twice
    optional<expr> inst = m_ctx.mk_class_instance_at(lctx, C);
    if (!inst) {
        metavar_context mctx   = m_ctx.mctx();
        local_context new_lctx = lctx.instantiate_mvars(mctx);
        new_lctx = erase_inaccessible_annotations(new_lctx);
        tactic_state s = ::lean::mk_tactic_state_for(m_env, m_opts, m_decl_name, mctx, new_lctx, C);
        return recoverable_error(some_expr(C), ref, elaborator_exception(
                ref, format("failed to synthesize type class instance for") + line() + s.pp())
            .ignore_if(has_synth_sorry({C})));
    }
    return *inst;
}

expr elaborator::mk_instance_core(expr const & C, expr const & ref) {
    return mk_instance_core(m_ctx.lctx(), C, ref);
}

/* We say a type class (Pi X, (C a_1 ... a_n)), where X may be empty, is
   ready to synthesize if it does not contain metavariables,
   or if the a_i's that contain metavariables are marked as output params. */
bool elaborator::ready_to_synthesize(expr inst_type) {
    if (!has_expr_metavar(inst_type))
        return true;
    while (is_pi(inst_type))
        inst_type = binding_body(inst_type);
    buffer<expr> C_args;
    expr const & C = get_app_args(inst_type, C_args);
    if (!is_constant(C))
        return false;
    expr it = m_ctx.infer(C);
    for (expr const & C_arg : C_args) {
        if (!is_pi(it))
            return false; /* failed */
        expr const & d = binding_domain(it);
        if (has_expr_metavar(C_arg) && !is_class_out_param(d))
            return false;
        it = binding_body(it);
    }
    return true;
}

expr elaborator::mk_instance(expr const & C, expr const & ref) {
    if (!ready_to_synthesize(C)) {
        expr inst = mk_metavar(C, ref);
        m_instances = cons(inst, m_instances);
        return inst;
    } else {
        return mk_instance_core(C, ref);
    }
}

expr elaborator::instantiate_mvars(expr const & e) {
    expr r = m_ctx.instantiate_mvars(e);
    return r;
}

level elaborator::get_level(expr const & A, expr const & ref) {
    expr A_type = whnf(infer_type(A));
    if (is_sort(A_type)) {
        return sort_level(A_type);
    }

    if (is_metavar_app(A_type)) {
        level l = mk_univ_metavar();
        if (try_is_def_eq(A_type, mk_sort(l))) {
            return l;
        }
    }

    auto pp_fn = mk_pp_ctx();
    throw elaborator_exception(ref, pp_type_expected(mk_fmt_ctx(), A, &A_type));
}

level elaborator::replace_univ_placeholder(level const & l) {
    auto fn = [&](level const & l) {
        if (is_placeholder(l))
            return some_level(mk_univ_metavar());
        else
            return none_level();
    };
    return replace(l, fn);
}

/* Here, we say a term is first-order IF all applications are of the form (f ...) where f is a constant. */
static bool is_first_order(expr const & e) {
    return !find(e, [&](expr const & e, unsigned) {
            return is_app(e) && !is_constant(get_app_fn(e));
        });
}

bool elaborator::is_elim_elab_candidate(name const & fn) {
    return get_elaborator_strategy(m_env, fn) == elaborator_strategy::AsEliminator;
}

/* Temporary hack for get_elim_info_for_builtin.
   It doesn't work for drec recursors for inductive predicates.
   TODO(Leo): fix it. */
static bool is_basic_aux_recursor(environment const & env, name const & n) {
    if (!is_aux_recursor(env, n))
        return false;
    return n.get_string() != "drec";
}

/** See comment at elim_info */
auto elaborator::get_elim_info_for_builtin(name const & fn) -> elim_info {
    lean_assert(is_basic_aux_recursor(m_env, fn) || is_recursor(m_env, fn));
    /* Remark: this is not just an optimization. The code at use_elim_elab_core
       only works for dependent elimination. */
    lean_assert(!fn.is_atomic());
    name const & I_name    = fn.get_prefix();

    unsigned nparams;
    unsigned nindices;
    unsigned nminors;

    constant_info I_info = m_env.get(I_name);
    lean_assert(I_info.is_inductive());
    inductive_val I_val  = I_info.to_inductive_val();
    nparams              = I_val.get_nparams();
    nindices             = I_val.get_nindices();
    nminors              = length(I_val.get_cnstrs());

    elim_info r;
    if (fn.get_string() == g_brec_on || fn.get_string() == g_binduction_on) {
        r.m_arity      = nparams + 1 /* motive */ + nindices + 1 /* major */ + 1;
    } else {
        r.m_arity      = nparams + 1 /* motive */ + nindices + 1 /* major */ + nminors;
    }
    r.m_nexplicit  = 1 /* major premise */ + nminors;
    if (nminors == 0) {
        /* The motive is marked as explicit in builtin recursors that do not have
           minor premises */
        r.m_nexplicit++;
    }
    r.m_motive_idx = nparams;
    unsigned major_idx;
    constant_info fn_info = m_env.get(fn);
    if (fn_info.is_recursor()) {
        major_idx = fn_info.to_recursor_val().get_major_idx();
    } else {
        major_idx = nparams + 1 + nindices;
    }
    r.m_idxs = to_list(major_idx);
    return r;
}

/** See comment at elim_info */
auto elaborator::use_elim_elab_core(name const & fn) -> optional<elim_info> {
    if (!is_elim_elab_candidate(fn))
        return optional<elim_info>();
    if (is_basic_aux_recursor(m_env, fn) || is_recursor(m_env, fn)) {
        return optional<elim_info>(get_elim_info_for_builtin(fn));
    }
    type_context_old::tmp_locals locals(m_ctx);
    constant_info d   = m_env.get(fn);
    expr type         = d.get_type();
    while (is_pi(type)) {
        type = instantiate(binding_body(type), locals.push_local_from_binding(type));
    }

    buffer<expr> C_args;
    expr const & C = get_app_args(type, C_args);
    if (!is_local(C) || C_args.empty() || !std::all_of(C_args.begin(), C_args.end(), is_local)) {
        format msg = format("'eliminator' elaboration is not used for '") + format(fn) +
            format("' because resulting type is not of the expected form\n");
        m_elim_failure_info.insert(fn, msg);
        return optional<elim_info>();
    }

    buffer<expr> const & params = locals.as_buffer();
    optional<unsigned> _midx = params.index_of(C);
    if (!_midx)
        return optional<elim_info>();

    unsigned midx = *_midx;
    buffer<unsigned> idxs;
    buffer<bool>     found;
    found.resize(C_args.size(), false);
    unsigned i    = params.size();
    unsigned nexplicit = 0;
    while (i > 0) {
        --i;
        expr const & param = params[i];

        if (!is_explicit(local_info(param))) {
            continue;
        }
        nexplicit++;

        if (optional<unsigned> pos = C_args.index_of(param)) {
            // Parameter is an argument of the resulting type (C ...)
            if (!found[*pos]) {
                // We store it if we could not infer it using the type of other arguments.
                found[*pos] = true;
                idxs.push_back(i);
            }
        }

        expr param_type = m_ctx.infer(param);
        if (!is_first_order(param_type))
            continue;

        bool collected = false;
        for_each(param_type, [&](expr const & e, unsigned) {
                if (is_local(e)) {
                    if (optional<unsigned> pos = C_args.index_of(e)) {
                        if (!found[*pos]) {
                            collected   = true;
                            found[*pos] = true;
                        }
                    }
                }
                return true;
            });
        if (collected)
            idxs.push_back(i);
    }

    for (unsigned i = 0; i < found.size(); i++) {
        if (!found[i]) {
            format msg = format("'eliminator' elaboration is not used for '") + format(fn) +
                format("' because a (reliable) way to synthesize '") + pp(C_args[i]) +
                format("', which occurs in the resulting type, was not found\n");
            m_elim_failure_info.insert(fn, msg);
            return optional<elim_info>();
        }
    }

    std::reverse(idxs.begin(), idxs.end());
    trace_elab_detail(tout() << "'eliminator' elaboration is going to be used for '" << fn << "' applications, "
                      << "the motive is computed using the argument(s):";
                      for (unsigned idx : idxs) tout() << " #" << (idx+1);
                      tout() << "\n";);
    return optional<elim_info>(params.size(), nexplicit, midx, to_list(idxs));
}

/** See comment at elim_info */
auto elaborator::use_elim_elab(name const & fn) -> optional<elim_info> {
    if (auto it = m_elim_cache.find(fn))
        return *it;
    optional<elim_info> r = use_elim_elab_core(fn);
    m_elim_cache.insert(fn, r);
    return r;
}

void elaborator::trace_coercion_failure(expr const & e_type, expr const & type, expr const & ref, char const * error_msg) {
    trace_elab({
            auto pp_fn = mk_pp_ctx();
            format msg("coercion at ");
            msg += format(pos_string_for(ref));
            msg += space() + format("from");
            msg += pp_indent(pp_fn, e_type);
            msg += line() + format("to");
            msg += pp_indent(pp_fn, type);
            msg += line() + format(error_msg);
            tout() << msg << "\n";
        });
}

optional<expr> elaborator::mk_Prop_to_bool_coercion(expr const & e, expr const & ref) {
    expr dec    = mk_app(mk_constant(get_decidable_name()), e);
    expr inst   = mk_instance(dec, ref);
    expr r      = mk_app(mk_constant(get_decidable_decide_name()), e, inst);
    return some_expr(r);
}

static bool is_thunk(expr const & e) {
    return is_app_of(e, get_thunk_name(), 1);
}

optional<expr> elaborator::mk_coercion_core(expr const & e, expr const & e_type, expr const & type, expr const & ref) {
    if (e_type == mk_Prop() && m_ctx.is_def_eq(type, mk_bool())) {
        return mk_Prop_to_bool_coercion(e, ref);
    } else if (is_thunk(type) && m_ctx.is_def_eq(e_type, app_arg(type))) {
        return some_expr(::lean::mk_app(mk_constant(name{"Thunk", "mk"}, const_levels(app_fn(type))),
                                        app_arg(type),
                                        ::lean::mk_lambda("_", mk_constant(get_unit_name()), e)));
    } else if (!has_expr_metavar(e_type) && !has_expr_metavar(type)) {
        expr has_coe_t;
        try {
            has_coe_t = mk_app(m_ctx, get_has_coe_t_name(), e_type, type);
        } catch (app_builder_exception & ex) {
            trace_coercion_failure(e_type, type, ref,
                                   "failed create type class expression 'has_coe_t' "
                                   "('set_option trace.app_builder true' for more information)");
            return none_expr();
        }
        optional<expr> inst;
        try {
            inst = m_ctx.mk_class_instance_at(m_ctx.lctx(), has_coe_t);
        } catch (class_exception &) {
            trace_coercion_failure(e_type, type, ref,
                                   "failed to synthesize class instance for 'has_coe_t' "
                                   "('set_option trace.class_instances true' for more information)");
            return none_expr();
        }
        if (!inst) {
            trace_coercion_failure(e_type, type, ref,
                                   "failed to synthesize 'has_coe_t' type class instance "
                                   "('set_option trace.class_instances true' for more information)");
            return none_expr();
        }
        level u_1 = get_level(e_type, ref);
        level u_2 = get_level(type, ref);
        expr coe_to_lift = mk_app(mk_constant(get_coe_to_lift_name(), {u_1, u_2}), e_type, type, *inst);
        expr coe         = mk_app(mk_constant(get_coe_name(), {u_1, u_2}), e_type, type, coe_to_lift, e);
        return some_expr(coe);
    } else {
        return none_expr();
    }
}

bool elaborator::is_monad(expr const & e) {
    try {
        expr m = mk_app(m_ctx, get_monad_name(), e);
        return static_cast<bool>(m_ctx.mk_class_instance(m));
    } catch (app_builder_exception &) {
        return false;
    } catch (class_exception &) {
        return false;
    }
}

bool elaborator::is_monad_fail(expr const & e) {
    try {
        expr m = mk_app(m_ctx, get_monad_fail_name(), e);
        return static_cast<bool>(m_ctx.mk_class_instance(m));
    } catch (app_builder_exception &) {
        return false;
    } catch (class_exception &) {
        return false;
    }
}

/*
   When lifting monads in do-notation and/or bind, it is very common to have coercion problems such as

          tactic name  ===>  solver ?a

   Coercion resolution cannot be used because (solver ?a) contains meta-variables. Recall that
   coercion resolution is based on type class resolution, and we can only synthesize type class instances
   if the type does not contain meta-variables.

   The coercion problem above is generated in scenarios such as

       do v ← t1,
          ...

   which is notation for

       @bind ?m ?inst ?a ?b t1 (fun v : ?a, ...)

   Now, assume (t1 : tactic name) and the expected type is (solver unit).
   Then, the following meta-variables can be resolved.

        ?m    := solver
        ?b    := unit
        ?inst := solver.monad

   and we get

       @bind solver solver.monad ?a unit t1 (fun v : ?a, ...)

   At this point, we get a type mismatch at t1 because th expected type is (solver ?a) and the given type
   is (tactic name).

   In this method, we consider the following compromise: we assign ?a := name, and then, try to perform
   coercion resolution again.

   Remark: this method also handle the case where the metavariable is at e_type. Example:

          tactic ?a    ===> smt_tactic unit

   TODO(leo): can/should we generalize this approach? */
optional<expr> elaborator::try_monad_coercion(expr const & e, expr e_type, expr type, expr const & ref) {
    if ((has_expr_metavar(e_type) && has_expr_metavar(type))
        || (!has_expr_metavar(e_type) && !has_expr_metavar(type))
        || !is_app(e_type)
        || !is_app(type)
        || has_expr_metavar(app_fn(type))
        || has_expr_metavar(app_fn(e_type))
        || (!is_metavar(app_arg(e_type)) && !is_metavar(app_arg(type)))
        || !is_monad(app_fn(e_type))
        || !is_monad(app_fn(type))) {
        /* Not applicable */
        return none_expr();
    }
    if (!m_ctx.is_def_eq(app_arg(e_type), app_arg(type)))
        return none_expr();
    e_type = instantiate_mvars(e_type);
    type   = instantiate_mvars(type);
    return mk_coercion_core(e, e_type, type, ref);
}

optional<expr> elaborator::mk_coercion(expr const & e, expr e_type, expr type, expr const & ref) {
    if (!m_coercions) return none_expr();
    synthesize_type_class_instances();
    e_type = instantiate_mvars(e_type);
    type   = instantiate_mvars(type);
    if (auto r = try_monad_coercion(e, e_type, type, ref)) {
        return r;
    }
    if (!has_expr_metavar(e_type)) {
        auto whnf_type = whnf(type);
        if (is_pi(whnf_type)) {
            if (auto r = mk_coercion_to_fn(e, e_type, ref)) {
                return r;
            }
        }
        if (is_sort(whnf_type)) {
            if (auto r = mk_coercion_to_sort(e, e_type, ref)) {
                return r;
            }
        }
        if (!has_expr_metavar(type)) {
            return mk_coercion_core(e, e_type, type, ref);
        }
    }
    trace_coercion_failure(e_type, type, ref,
                            "was not considered because types contain metavariables");
    return none_expr();
}

bool elaborator::is_def_eq(expr const & e1, expr const & e2) {
    type_context_old::fo_unif_approx_scope  scope1(m_ctx);
    type_context_old::ctx_unif_approx_scope scope2(m_ctx);
    try {
        return m_ctx.is_def_eq(e1, e2);
    } catch (exception &) {
        return false;
    }
}

/* Check `e1 =?= e2` using all unifier approximation: first-order, context-compression and quasi-patterns. */
bool elaborator::is_def_eq_all_approx(expr const & e1, expr const & e2) {
    type_context_old::approximate_scope scope(m_ctx);
    try {
        return m_ctx.is_def_eq(e1, e2);
    } catch (exception &) {
        return false;
    }
}

bool elaborator::try_is_def_eq(expr const & e1, expr const & e2) {
    snapshot S(*this);
    flet<bool> dont_recover(m_recover_from_errors, false);
    try {
        return is_def_eq(e1, e2);
    } catch (exception &) {
        S.restore(*this);
        throw;
    }
    S.restore(*this);
    return false;
}

optional<expr> elaborator::ensure_has_type(expr const & e, expr const & e_type, expr const & type, expr const & ref) {
    if (is_def_eq(e_type, type))
        return some_expr(e);
    return mk_coercion(e, e_type, type, ref);
}

expr elaborator::enforce_type(expr const & e, expr const & expected_type, char const * header, expr const & ref) {
    expr e_type = infer_type(e);
    if (auto r = ensure_has_type(e, e_type, expected_type, ref)) {
        return *r;
    } else {
        auto exc = elaborator_exception(ref, format(header) + format(", term") +
                pp_type_mismatch(e, e_type, expected_type))
                .ignore_if(has_synth_sorry({e, e_type, expected_type}));
        return recoverable_error(some(expected_type), ref, exc);
    }
}

void elaborator::trace_coercion_fn_sort_failure(bool is_fn, expr const & e_type, expr const & ref, char const * error_msg) {
    trace_elab({
            format msg("coercion at ");
            auto pp_fn = mk_pp_ctx();
            msg += format(pos_string_for(ref));
            msg += space() + format("from");
            msg += pp_indent(pp_fn, e_type);
            if (is_fn)
                msg += line() + format("to function space");
            else
                msg += line() + format("to sort");
            msg += line() + format(error_msg);
            tout() << msg << "\n";
        });
}

optional<expr> elaborator::mk_coercion_to_fn_sort(bool is_fn, expr const & e, expr const & _e_type, expr const & ref) {
    if (!m_coercions) return none_expr();
    expr e_type = instantiate_mvars(_e_type);
    if (!has_expr_metavar(e_type)) {
        try {
            bool mask[3] = { true, false, true };
            expr args[2] = { e_type, e };
            expr new_e = mk_app(m_ctx, is_fn ? get_coe_fn_name() : get_coe_sort_name(), 3, mask, args);
            expr new_e_type = whnf(infer_type(new_e));
            if ((is_fn && is_pi(new_e_type)) || (!is_fn && is_sort(new_e_type))) {
                return some_expr(new_e);
            }
            trace_coercion_fn_sort_failure(is_fn, e_type, ref,
                                           "coercion was successfully generated, but resulting type is not the expected one");
            return none_expr();
        } catch (app_builder_exception & ex) {
            trace_coercion_fn_sort_failure(is_fn, e_type, ref,
                                           "failed create coercion application using type class resolution "
                                           "('set_option trace.app_builder true' and 'set_option trace.class_instances true' for more information)");
            return none_expr();
        }
    } else {
        trace_coercion_fn_sort_failure(is_fn, e_type, ref,
                                       "was not considered because type contain metavariables");
        return none_expr();
    }
}

expr elaborator::ensure_function(expr const & e, expr const & ref) {
    expr e_type = whnf(infer_type(e));
    if (is_pi(e_type)) {
        return e;
    }
    if (auto r = mk_coercion_to_fn(e, e_type, ref)) {
        return *r;
    }
    throw elaborator_exception(ref, pp_function_expected(mk_fmt_ctx(), e, e_type))
            .ignore_if(has_synth_sorry({e, e_type}));
}

expr elaborator::ensure_type(expr const & e, expr const & ref) {
    expr e_type = whnf(infer_type(e));
    if (is_sort(e_type)) {
        return e;
    }

    if (is_metavar_app(e_type) && is_def_eq(e_type, mk_sort(mk_univ_metavar()))) {
        return e;
    }

    if (auto r = mk_coercion_to_sort(e, e_type, ref)) {
        return *r;
    }

    report_or_throw(elaborator_exception(ref, pp_type_expected(mk_fmt_ctx(), e, &e_type)));
    // only create the metavar if can actually recover from the error
    return mk_sorry(some_expr(mk_sort(mk_univ_metavar())), ref);
}

static expr get_ref_for_child(expr const & arg, expr const & ref) {
    if (get_pos_info_provider() && get_pos_info_provider()->get_pos_info(arg)) {
        return arg;
    } else {
        /* using ref because position info for argument is not available */
        return ref;
    }
}

expr elaborator::visit_typed_expr(expr const & e) {
    expr val          = get_typed_expr_expr(e);
    expr ref          = val;
    expr type         = get_typed_expr_type(e);
    expr new_type;
    expr ref_type     = get_ref_for_child(type, e);
    new_type = ensure_type(visit(type, none_expr()), ref_type);
    synthesize_type_class_instances();
    expr new_val      = visit(val, some_expr(new_type));
    expr new_val_type = infer_type(new_val);
    if (auto r = ensure_has_type(new_val, new_val_type, new_type, ref))
        return *r;

    return recoverable_error(some_expr(new_type), ref, elaborator_exception(ref, format("invalid type ascription, term ") +
            pp_type_mismatch(new_val_type, new_type)));
}

level elaborator::dec_level(level const & l, expr const & ref) {
    if (auto d = ::lean::dec_level(l))
        return *d;
    level r = m_ctx.mk_univ_metavar_decl();
    if (!m_ctx.is_def_eq(mk_succ(r), l))
        throw elaborator_exception(ref, "invalid pre-numeral, universe level must be > 0");
    return r;
}

expr elaborator::visit_prenum(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_prenum(e));
    expr ref = e;
    mpz const & v  = prenum_value(e);
    expr A;
    if (expected_type) {
        A = *expected_type;
        if (is_metavar(*expected_type))
            m_numeral_types = cons(A, m_numeral_types);
    } else {
        A = mk_type_metavar(ref);
        m_numeral_types = cons(A, m_numeral_types);
    }
    level A_lvl = get_level(A, ref);
    levels ls(dec_level(A_lvl, ref));
    if (v.is_neg())
        return recoverable_error(some_expr(A), ref, elaborator_exception(ref, "invalid pre-numeral, it must be a non-negative value"));
    if (v.is_zero()) {
        expr has_zero_A = copy_pos(ref, mk_app(mk_constant(get_has_zero_name(), ls), A));
        expr S          = mk_instance(has_zero_A, ref);
        return copy_pos(ref, mk_app(copy_pos(ref, mk_app(mk_constant(get_has_zero_zero_name(), ls), A)), S));
    } else {
        expr has_one_A = copy_pos(ref, mk_app(mk_constant(get_has_one_name(), ls), A));
        expr S_one     = mk_instance(has_one_A, ref);
        expr one       = copy_pos(ref, mk_app(copy_pos(ref, mk_app(mk_constant(get_has_one_one_name(), ls), A)), S_one));
        if (v == 1) {
            return one;
        } else {
            expr has_add_A = copy_pos(ref, mk_app(mk_constant(get_has_add_name(), ls), A));
            expr S_add     = mk_instance(has_add_A, ref);
            std::function<expr(mpz const & v)> convert = [&](mpz const & v) {
                lean_assert(v > 0);
                if (v == 1)
                    return one;
                else if (v % mpz(2) == 0) {
                    expr r = convert(v / 2);
                    return copy_pos(ref, mk_app(copy_pos(ref, mk_app(copy_pos(ref, mk_app(mk_constant(get_bit0_name(), ls), A)), S_add)), r));
                } else {
                    expr r = convert(v / 2);
                    return copy_pos(ref, mk_app(copy_pos(ref, mk_app(copy_pos(ref, mk_app(copy_pos(ref, mk_app(mk_constant(get_bit1_name(), ls), A)), S_one)), S_add)), r));
                }
            };
            return convert(v);
        }
    }
}

expr elaborator::visit_sort(expr const & e) {
    level new_l = replace_univ_placeholder(sort_level(e));
    expr r = update_sort(e, new_l);
    if (has_placeholder(sort_level(e)))
        m_to_check_sorts.emplace_back(e, r);
    return r;
}

expr elaborator::visit_const_core(expr const & e) {
    constant_info d = m_env.get(const_name(e));
    buffer<level> ls;
    for (level const & l : const_levels(e)) {
        level new_l = replace_univ_placeholder(l);
        ls.push_back(new_l);
    }
    unsigned num_lparams = d.get_num_lparams();
    if (num_lparams < ls.size()) {
        format msg("incorrect number of universe levels parameters for '");
        msg += format(const_name(e)) + format("', #") + format(num_lparams);
        msg += format(" expected, #") + format(ls.size()) + format("provided");
        return recoverable_error({}, e, elaborator_exception(e, msg));
    }
    // "fill" with meta universe parameters
    for (unsigned i = ls.size(); i < num_lparams; i++)
        ls.push_back(mk_univ_metavar());
    lean_assert(num_lparams == ls.size());
    return update_constant(e, levels(ls));
}

expr elaborator::visit_function(expr const & fn, bool has_args, optional<expr> const & expected_type, expr const & ref) {
    expr ufn = unwrap_pos(fn);
    if (is_placeholder(ufn)) {
        throw elaborator_exception(ref, "placeholders '_' cannot be used where a function is expected");
    }
    if (is_field_notation(ufn))
        throw elaborator_exception(ref, "invalid occurrence of field notation");
    expr r;
    switch (ufn.kind()) {
    case expr_kind::BVar:
    case expr_kind::Pi:
    case expr_kind::MVar:
    case expr_kind::Sort:
    case expr_kind::Lit:
        throw elaborator_exception(ref, "invalid application, function expected");
    // The expr_kind::App case can only happen when nary notation is used
    case expr_kind::App:       r = visit(ufn, expected_type); break;
    case expr_kind::FVar:      r = ufn; break;
    case expr_kind::Const:     r = visit_const_core(ufn); break;
    case expr_kind::MData:     r = visit_mdata(ufn, expected_type, true); break;
    case expr_kind::Lambda:    r = visit_lambda(ufn, expected_type); break;
    case expr_kind::Let:       r = visit_let(ufn, expected_type); break;
    case expr_kind::Proj:      throw elaborator_exception(ref, "unexpected occurrence of proj constructor");
    }
    if (has_args)
        r = ensure_function(r, ref);
    return r;
}

void elaborator::validate_overloads(buffer<expr> const & fns, expr const & ref) {
    for (expr const & fn_i : fns) {
        if (is_constant(fn_i) && use_elim_elab(const_name(fn_i))) {
            auto pp_fn = mk_pp_ctx();
            format msg("invalid overloaded application, "
                       "elaborator has special support for '");
            msg += pp_fn(fn_i);
            msg += format("' (it is handled as an \"eliminator\"), "
                          "but this kind of constant cannot be overloaded "
                          "(solution: use fully qualified names) ");
            msg += pp_overloads(pp_fn, fns);
            throw elaborator_exception(ref, msg);
        }
    }
}

void elaborator::throw_app_type_mismatch_error(expr const & t, expr const & arg, expr const & arg_type,
                                               expr const & expected_type, expr const & ref) {
    format msg   = format("type mismatch at application");
    msg += pp_indent(mk_pp_ctx(), t);
    msg += line() + format("term") + pp_type_mismatch(arg, arg_type, expected_type);
    throw elaborator_exception(ref, msg).
            ignore_if(has_synth_sorry({arg, arg_type, expected_type}));
}

format elaborator::mk_app_arg_mismatch_error(expr const & t, expr const & arg, expr const & expected_arg) {
    auto pp_data = pp_until_different(mk_fmt_ctx(), arg, expected_arg);
    auto fmt     = std::get<0>(pp_data);
    format msg = format("unexpected argument at application");
    msg += pp_indent_expr(fmt, t);
    msg += line() + format("given argument");
    msg += std::get<1>(pp_data);
    msg += line() + format("expected argument");
    msg += std::get<2>(pp_data);
    return msg;
}

expr elaborator::visit_elim_app(expr const & fn, elim_info const & info, buffer<expr> const & args,
                                optional<expr> const & _expected_type, expr const & ref) {
    trace_elab_detail(tout() << "recursor/eliminator application at " << pos_string_for(ref) << "\n";);
    lean_assert(info.m_nexplicit <= args.size());
    if (!_expected_type) {
        throw elaborator_exception(ref, format("invalid '") + format(const_name(fn)) + format ("' application, ") +
                                   format("elaborator has special support for this kind of application ") +
                                   format("(it is handled as an \"eliminator\"), ") +
                                   format("but the expected type must be known"));
    }
    synthesize_type_class_instances();
    expr expected_type = instantiate_mvars(*_expected_type);
    if (has_expr_metavar(expected_type)) {
        auto pp_fn = mk_pp_ctx();
        throw elaborator_exception(ref, format("invalid '") + format(const_name(fn)) + format ("' application, ") +
                                   format("elaborator has special support for this kind of application ") +
                                   format("(it is handled as an \"eliminator\"), ") +
                                   format("but expected type must not contain metavariables") +
                                   pp_indent(pp_fn, expected_type));
    }

    trace_elab_debug(
        tout() << "eliminator elaboration for '" << fn << "'\n"
        << "  arity:     " << info.m_arity << "\n"
        << "  nexplicit: " << info.m_nexplicit << "\n"
        << "  motive:    #" << (info.m_motive_idx+1) << "\n"
        << "  \"major\":  ";
        for (unsigned idx : info.m_idxs)
            tout() << " #" << (idx+1);
        tout() << "\n";);

    expr fn_type = try_to_pi(infer_type(fn));
    buffer<expr> new_args;

    /* In the first pass we only process the arguments at info.m_idxs */
    expr type = fn_type;
    unsigned i = 0;
    unsigned j = 0;
    list<unsigned> main_idxs  = info.m_idxs;
    buffer<optional<expr>> postponed_args; // mark arguments that must be elaborated in the second pass.
    {
        while (is_pi(type)) {
            expr const & d = binding_domain(type);
            binder_info bi = binding_info(type);
            expr new_arg;
            optional<expr> postponed;
            if (std::find(main_idxs.begin(), main_idxs.end(), i) != main_idxs.end()) {
                {
                    new_arg = visit(args[j], some_expr(d));
                    synthesize();
                    new_arg = instantiate_mvars(new_arg);
                }
                j++;
                if (has_expr_metavar(new_arg)) {
                    auto pp_fn = mk_pp_ctx();
                    throw elaborator_exception(ref, format("invalid '") + format(const_name(fn)) +
                                               format ("' application, ") +
                                               format("elaborator has special support for this kind of application ") +
                                               format("(it is handled as an \"eliminator\"), ") +
                                               format("but term") + pp_indent(pp_fn, new_arg) +
                                               line() + format("must not contain metavariables because") +
                                               format(" it is used to compute the motive"));
                }
                expr new_arg_type = infer_type(new_arg);
                if (!is_def_eq(new_arg_type, d)) {
                    new_args.push_back(new_arg);
                    throw_app_type_mismatch_error(mk_app(fn, new_args), new_arg, new_arg_type, d, ref);
                }
            } else if (is_explicit(bi)) {
                expr arg_ref = args[j];
                new_arg      = mk_metavar(d, arg_ref);
                postponed    = args[j];
                j++;
            } else if (is_inst_implicit(bi)) {
                new_arg = mk_instance(d, ref);
            } else {
                new_arg = mk_metavar(d, ref);
            }
            new_args.push_back(new_arg);
            postponed_args.push_back(postponed);
            type = try_to_pi(instantiate(binding_body(type), new_arg));
            i++;
        }

        lean_assert(new_args.size() == info.m_arity);

        /* Process extra arguments */
        for (; j < args.size(); j++) {
            new_args.push_back(visit(args[j], none_expr()));
        }
        synthesize();
    }

    /* Compute expected_type for the recursor application without extra arguments */
    buffer<expr> extra_args;
    i = new_args.size();
    while (i > info.m_arity) {
        --i;
        expr new_arg      = instantiate_mvars(new_args[i]);
        expr new_arg_type = instantiate_mvars(infer_type(new_arg));
        expected_type     = ::lean::mk_pi("_a", new_arg_type, kabstract(m_ctx, expected_type, new_arg));
        extra_args.push_back(new_arg);
    }
    new_args.shrink(i);
    std::reverse(extra_args.begin(), extra_args.end());

    // Compute motive */
    trace_elab_debug(tout() << "compute motive by using keyed-abstraction:\n  " <<
                     instantiate_mvars(type) << "\nwith\n  " <<
                     expected_type << "\n";);
    expr motive = expected_type;
    buffer<expr> keys;
    get_app_args(type, keys);
    i = keys.size();
    while (i > 0) {
        --i;
        expr k = instantiate_mvars(keys[i]);
        expr k_type    = infer_type(k);
        motive = ::lean::mk_lambda("_x", k_type, kabstract(m_ctx, motive, k));
    }
    trace_elab_debug(tout() << "motive:\n  " << instantiate_mvars(motive) << "\n";);

    expr motive_arg = new_args[info.m_motive_idx];
    trace_elab_debug(tout() << "motive_arg:\n  " << motive_arg << "\n";);
    if (!is_def_eq_all_approx(motive_arg, motive)) {
        throw elaborator_exception(ref, "\"eliminator\" elaborator failed to compute the motive");
    }

    try {
        /* Elaborate postponed arguments */
        for (unsigned i = 0; i < new_args.size(); i++) {
            if (optional<expr> arg = postponed_args[i]) {
                lean_assert(is_metavar(new_args[i]));
                expr new_arg_type = instantiate_mvars(infer_type(new_args[i]));
                expr new_arg      = visit(*arg, some_expr(new_arg_type));
                if (!is_def_eq(new_args[i], new_arg)) {
                    throw elaborator_exception(ref, format("\"eliminator\" elaborator type mismatch, term") +
                                               pp_type_mismatch(new_arg, infer_type(new_arg), new_arg_type));
                } else {
                    new_args[i] = new_arg;
                }
            }
        }

        expr r = instantiate_mvars(mk_app(mk_app(fn, new_args), extra_args));
        trace_elab_debug(tout() << "elaborated recursor:\n  " << r << "\n";);
        return r;
    } catch (elaborator_exception & ex) {
        // TODO(gabriel): the additional information is not added in error-recovery mode
        throw nested_elaborator_exception(ref, std::current_exception(),
                                          format("the inferred motive for the eliminator-like application is") +
                                          pp_indent(motive));
    }
}

struct elaborator::first_pass_info {
    buffer<expr> args_mvars;
    buffer<expr> args_expected_types;
    buffer<expr> new_args;
    /* new_args_size[i] contains size of new_args after args_mvars[i] was pushed.
       We need this information for producing error messages. */
    buffer<unsigned> new_args_size;
    buffer<expr>     new_instances;
    /* new_instances_size[i] contains the size of new_instances before (and after) args_mvars[i]
       was pushed. */
    buffer<unsigned> new_instances_size;
    /* Store arguments that need to be abstracted when we apply eta expansion for function applications
       containing optional and auto parameters. */
    buffer<expr>     eta_args;
};

expr elaborator::mk_auto_param(expr const &, expr const &, expr const &) {
    throw exception("auto_param has been disabled (we removed the tactic framework");
}


optional<expr> elaborator::process_optional_and_auto_params(expr type, expr const & ref, buffer<expr> & eta_args, buffer<expr> & new_args) {
    unsigned sz1 = eta_args.size();
    unsigned sz2 = new_args.size();
    optional<expr> result_type;
    while (true) {
        expr it = whnf(type);
        if (!is_pi(it))
            break;
        type = it;
        expr const & d = binding_domain(type);
        expr new_arg;
        bool found = false;
        if (auto def_value = is_optional_param(d)) {
            found   = true;
            new_arg = *def_value;
        } else if (auto p = is_auto_param(d)) {
            found   = true;
            new_arg = mk_auto_param(p->second, p->first, ref);
        } else {
            new_arg = mk_local(mk_fresh_name(), binding_name(type), d, binding_info(type));
            eta_args.push_back(new_arg);
        }
        new_args.push_back(new_arg);
        type = instantiate(binding_body(type), new_arg);
        if (found) {
            result_type = type;
            sz1 = eta_args.size();
            sz2 = new_args.size();
        }
    }
    eta_args.shrink(sz1);
    new_args.shrink(sz2);
    if (result_type)
        return some_expr(Pi(eta_args, *result_type));
    else
        return result_type;
}

expr elaborator::post_process_implicit_arg(expr const & arg, expr const & /* ref */) {
    return arg;
}

/* Check if fn args resulting type matches the expected type, and fill
   first_pass_info & info with information collected in this first pass.
   Return true iff the types match.

   Remark: the arguments \c args are *not* visited in this first pass.
   They are only used in this method to provide location information. */
void elaborator::first_pass(expr const & fn, buffer<expr> const & args,
                            expr const & expected_type, expr const & ref,
                            first_pass_info & info) {
    expr fn_type          = infer_type(fn);
    expr type_before_whnf = fn_type;
    expr type             = whnf(fn_type);
    unsigned i   = 0;
    /* First pass: compute type for an fn-application, and unify it with expected_type.
       We don't visit expelicit arguments at this point. */

    /* Outer loop is used to make sure we consume implicit arguments occurring after auto/option params. */
    while (true) {
        while (is_pi(type)) {
            binder_info bi = binding_info(type);
            expr const & d = binding_domain(type);
            if (is_strict_implicit(bi) && i == args.size())
                break;
            expr new_arg;
            if (!is_explicit(bi)) {
                // implicit argument
                new_arg = mk_metavar(binding_name(type), d, ref);
                if (is_inst_implicit(bi))
                    info.new_instances.push_back(new_arg);
                new_arg = post_process_implicit_arg(new_arg, ref);
            } else if (i < args.size()) {
                // explicit argument
                expr const & arg_ref = args[i];
                info.args_expected_types.push_back(d);
                if (is_as_is(args[i])) {
                    /* We check the type of as-is arguments eagerly, and
                       we don't create a metavariable for them since they
                       have already been elaborated.

                       This is important when we are elaborating terms such as

                       l.map (λ ⟨a, b⟩, a + b)

                       where (l : list (nat × nat))

                       We elaborate l when we process l.map, and convert it into

                       list.map (λ ⟨a, b⟩, a + b) (as-is l)

                       By checking the type of l here, we make sure that the
                       domain of the function (λ ⟨a, b⟩, a + b) is known when
                       we elaborate it.

                       Note that if the user types

                       list.map (λ ⟨a, b⟩, a + b) l
                                 --^ fails here

                       It will fail because we elaborate from left to right, and
                       we don't have the type of l.

                       See discussion at #1403
                    */
                    new_arg = get_as_is_arg(args[i]);
                    expr arg_expected_type;
                    arg_expected_type = d;
                    expr new_arg_type = infer_type(new_arg);
                    optional<expr> new_new_arg = ensure_has_type(new_arg, new_arg_type, arg_expected_type, arg_ref);
                    if (!new_new_arg) {
                        buffer<expr> tmp_args;
                        tmp_args.append(info.new_args);
                        tmp_args.push_back(new_arg);
                        throw_app_type_mismatch_error(mk_app(fn, tmp_args), new_arg, new_arg_type, arg_expected_type, ref);
                    }
                    new_arg = *new_new_arg;
                } else {
                    new_arg = mk_metavar(d, arg_ref);
                }
                i++;
                lean_assert(!get_pos(new_arg));
                info.args_mvars.push_back(new_arg);
                info.new_args_size.push_back(info.new_args.size());
                info.new_instances_size.push_back(info.new_instances.size());
            } else {
                break;
            }
            info.new_args.push_back(new_arg);
            /* See comment above at visit_base_app_core */
            type_before_whnf = instantiate(binding_body(type), new_arg);
            type             = whnf(type_before_whnf);
        }
        type = type_before_whnf;
        if (optional<expr> new_type = process_optional_and_auto_params(type, ref, info.eta_args, info.new_args)) {
            type = *new_type;
            /* If next argument is implicit, then keep consuming */
            type_before_whnf = *new_type;
            type             = whnf(type_before_whnf);
            if (!is_pi(type) || is_explicit(binding_info(type))) {
                type = type_before_whnf;
                break;
            }
        } else {
            break;
        }
    }

    if (i != args.size()) {
        /* failed to consume all explicit arguments, use base elaboration for applications */
        throw elaborator_exception(ref, "too many arguments");
    }
    lean_assert(args.size() == info.args_expected_types.size());
    lean_assert(args.size() == info.args_mvars.size());
    lean_assert(args.size() == info.new_args_size.size());
    lean_assert(args.size() == info.new_instances_size.size());

    if (!is_def_eq(expected_type, type)) {
        expr e = mk_app(fn, info.new_args);
        throw elaborator_exception(ref, format("type mismatch, term") + pp_type_mismatch(e, type, expected_type))
            .ignore_if(has_synth_sorry({type, expected_type, e}));
    }
}

std::tuple<expr, expr, optional<expr>> elaborator::elaborate_arg(expr const & arg, expr const & expected_type, expr const & ref) {
    expr aux_expected_type = expected_type;
    expr new_arg = visit(arg, some_expr(aux_expected_type));
    expr new_arg_type = infer_type(new_arg);
    return std::make_tuple(new_arg, new_arg_type, ensure_has_type(new_arg, new_arg_type, expected_type, ref));
}

/* Using the information colllected in the first-pass, visit the arguments args.
   And then, create resulting application */
expr elaborator::second_pass(expr const & fn, buffer<expr> const & args,
                             expr const & ref, first_pass_info & info) {
    unsigned j = 0; /* for traversing new_instances */
    /* Second pass: visit explicit arguments using the information
       we gained about their expected types */
    for (unsigned i = 0; i < args.size(); i++) {
        /* Process type class instances upto args[i] */
        for (; j < info.new_instances_size[i]; j++) {
            expr const & mvar = info.new_instances[j];
            if (!try_synthesize_type_class_instance(mvar))
                m_instances = cons(mvar, m_instances);
        }
        expr ref_arg       = get_ref_for_child(args[i], ref);
        expr expected_type = info.args_expected_types[i];
        info.new_args[info.new_args_size[i]] = recover_expr_from_exception(some_expr(expected_type), ref_arg, [&] {
            if (is_metavar(info.args_mvars[i])) {
                expr new_arg; expr new_arg_type; optional<expr> new_new_arg;
                std::tie(new_arg, new_arg_type, new_new_arg) = elaborate_arg(args[i], expected_type, ref_arg);
                if (!new_new_arg) {
                    buffer<expr> tmp_args;
                    tmp_args.append(info.new_args_size[i], info.new_args.data());
                    tmp_args.push_back(new_arg);
                    throw_app_type_mismatch_error(mk_app(fn, tmp_args), new_arg, new_arg_type,
                                                  info.args_expected_types[i], ref);
                }
                if (!is_def_eq(info.args_mvars[i], *new_new_arg)) {
                    buffer<expr> tmp_args;
                    tmp_args.append(info.new_args_size[i], info.new_args.data());
                    tmp_args.push_back(new_arg);
                    format msg = mk_app_arg_mismatch_error(mk_app(fn, tmp_args),
                                                           new_arg, info.args_mvars[i]);
                    report_or_throw(elaborator_exception(ref, msg).
                        ignore_if(has_synth_sorry({new_arg, instantiate_mvars(info.args_mvars[i])})));
                }
                return *new_new_arg;
            } else {
                return info.args_mvars[i];
            }
        });
    }
    for (; j < info.new_instances.size(); j++) {
        expr const & mvar = info.new_instances[j];
        if (!try_synthesize_type_class_instance(mvar))
            m_instances = cons(mvar, m_instances);
    }
    expr e = Fun(info.eta_args, mk_app(fn, info.new_args.size(), info.new_args.data()));
    for (auto const & new_arg : info.new_args)
        if (m_user_mvars.count(new_arg))
            m_user_mvars[new_arg].m_context = some_expr(e);
    return e;
}

bool elaborator::is_with_expected_candidate(expr const & fn) {
    /* When processing expressions such as (l^.for f), we first resolve the field notation obtaining
           (list.for l)
       Then, when processing ((list.for l) f), we still want to use the expected type.
       So, we should retrieve the constant list.for using get_app_fn.
    */
    expr _fn = get_app_fn(fn);
    if (!is_constant(_fn)) return false;
    return get_elaborator_strategy(m_env, const_name(_fn)) == elaborator_strategy::WithExpectedType;
}

expr elaborator::visit_base_app_simple(expr const & _fn, arg_mask amask, buffer<expr> const & args,
                                       bool args_already_visited, optional<expr> const & expected_type, expr const & ref) {
    expr fn      = _fn;
    expr fn_type = infer_type(fn);
    unsigned i = 0;
    buffer<expr> new_args;

    /* We manually track the type before whnf. We do that because after the loop
       we check whether the application type is definitionally equal to expected_type.
       Suppose, the result type is (tactic expr) and the expected type is (?M1 ?M2).
       The unification problem can be solved using first-order unification, but if we
       unfold (tactic expr), we get (tactic_state -> base_tactic_result ...) which cannot.

       The statement
         expr type = try_to_pi(fn_type);
       also does not work because (tactic expr) unfolds into a type. */
    expr type_before_whnf = fn_type;
    expr type             = whnf(fn_type);
    buffer<expr> eta_args;
    /* Outer loop is used to make sure we consume implicit arguments occurring after auto/option params. */
    while (true) {
        while (true) {
            if (is_pi(type)) {
                binder_info bi = binding_info(type);
                expr const & d = binding_domain(type);
                expr new_arg;
                if (amask == arg_mask::Default && is_strict_implicit(bi) && i == args.size())
                    break;
                if ((amask == arg_mask::Default && !is_explicit(bi)) ||
                    (amask == arg_mask::InstHoExplicit && !is_explicit(bi) && !is_inst_implicit(bi) && !is_pi(d))) {
                    // implicit argument
                    if (is_inst_implicit(bi))
                        new_arg = mk_instance(d, ref);
                    else
                        new_arg = mk_metavar(binding_name(type), d, ref);
                    new_arg = post_process_implicit_arg(new_arg, ref);
                } else if (i < args.size()) {
                    expr expected_type = d;
                    // explicit argument
                    expr ref_arg = get_ref_for_child(args[i], ref);
                    if (args_already_visited) {
                        new_arg = args[i];
                    } else if (is_inst_implicit(bi) && is_placeholder(args[i])) {
                        lean_assert(amask != arg_mask::Default);
                    /* If '@' or '@@' have been used, and the argument is '_', then
                       we use type class resolution. */
                        new_arg = mk_instance(d, ref);
                    } else {
                        new_arg = visit(args[i], some_expr(expected_type));
                    }
                    expr new_arg_type = infer_type(new_arg);
                    if (optional<expr> new_new_arg = ensure_has_type(new_arg, new_arg_type, d, ref_arg)) {
                        new_arg = *new_new_arg;
                    } else {
                        new_args.push_back(new_arg);
                        throw_app_type_mismatch_error(mk_app(fn, new_args.size(), new_args.data()),
                                                      new_arg, new_arg_type, d, ref);
                    }
                    i++;
                } else {
                    break;
                }
                new_args.push_back(new_arg);
                /* See comment above at first type_before_whnf assignment */
                type_before_whnf = instantiate(binding_body(type), new_arg);
                type             = whnf(type_before_whnf);
           } else if (i < args.size()) {
                bool progress = false;
                /* If type is of the form `?m ...`, we may try to synthesize pending type class problems,
                   and check whether `?m` has been instantiated or not.

                   We need this trick to handle `monad_run.run`. This function has type
                   ```
                   run : Π {out m : Type u_1 → Type u_2} [c : monad_run out m] {α : Type u_1}, m α → out α
                   ```
                   The resultant type `out α` depends on resolving the type class resolution problem `monad_run out m`
                   since `out` is marked as an `out_param`.

                   Without this approach, we would have to write
                   ```
                   @[reducible] def type_checker_m := except_t format (reader_t (environment × list result) (state_t context id))

                   def type_checker_m.run {α} (a : type_checker_m α) (env : environment) (r : list result) : except format α :=
                   (run a (env, r) mk_context).1
                   ```
                   as
                   ```
                   @[reducible] def type_checker_m := except_t format (reader_t (environment × list result) (state_t context id))

                   def type_checker_m.run {α} (a : type_checker_m α) (env : environment) (r : list result) : except format α :=
                   let tmp := run a in
                   (tmp (env, r) mk_context).1
                   ```
                   or completely avoid `run`. */
                if (is_metavar_app(type)) {
                    synthesize_type_class_instances();
                    expr new_type = instantiate_mvars(type);
                    if (new_type != type) {
                        type = new_type;
                        progress = true;
                    }
                }
                if (!progress) {
                    expr new_fn = mk_app(fn, new_args.size(), new_args.data());
                    new_args.clear();
                    fn = ensure_function(new_fn, ref);
                    type_before_whnf = infer_type(fn);
                    type = whnf(type_before_whnf);
                }
            } else {
                lean_assert(i == args.size());
                break;
            }
        }
        type = instantiate_mvars(type_before_whnf);

        /* We ignore optional/auto params when `@` is used */
        if (amask != arg_mask::Default)
            break;

        if (optional<expr> new_type = process_optional_and_auto_params(type, ref, eta_args, new_args)) {
            /* If next argument is implicit, then keep consuming */
            type_before_whnf = *new_type;
            type             = whnf(type_before_whnf);
            if (!is_pi(type) || is_explicit(binding_info(type))) {
                type = type_before_whnf;
                break;
            }
        } else {
            break;
        }
    }

    expr r = Fun(eta_args, mk_app(fn, new_args.size(), new_args.data()));
    for (auto const & new_arg : new_args)
        if (m_user_mvars.count(new_arg))
            m_user_mvars[new_arg].m_context = some_expr(r);
    if (expected_type) {
        if (auto new_r = ensure_has_type(r, type, *expected_type, ref)) {
            return *new_r;
        } else {
            /* We do not generate the error here because we can produce a better one from
               the caller (i.e., place the set the expected_type) */
        }
    }
    return r;
}

expr elaborator::visit_base_app_core(expr const & fn, arg_mask amask, buffer<expr> const & args,
                                     bool args_already_visited, optional<expr> const & expected_type, expr const & ref) {
    /** Check if this application is a candidate for propagating the expected type to arguments */
    if (args_already_visited || /* if the arguments have already been visited, then there is no point. */
        amask != arg_mask::Default || /* we do not propagate expected type info when @ and @@ are used */
        !is_with_expected_candidate(fn) ||
        !expected_type) {
        return visit_base_app_simple(fn, amask, args, args_already_visited, expected_type, ref);
    }

    snapshot C(*this);
    first_pass_info info;
    try {
        /* In the first pass, we skip universe contraints such as

               (max 1 ?m) =?= ?m
               (max ?m1 1) =?= (max 1 ?m2)

           The first one cannot be solved by type_context_old, and an approximate
           solution is used for the second one. In the second pass, we will have
           additional information propagated from the expected_type, and these
           constraints may become trivial.

           The following definition illustrates the issue:

              meta def foo (ex_lst : list name) (e : expr) : list name :=
              expr.fold e [] (λ _ _ l, l)

           expr.fold has type

              meta constant expr.fold {α : Type} : expr → α → (expr → nat → α → α) → α

           So, when processing [], we have to unify ?α with (list ?m), where

                     ?α      : Type 1
                     list ?m : Type (max 1 ?u)

           Thus, we also have to solve

                   1 =?= (max 1 ?u)

           which, as described above, cannot be solved by type_context_old.
           However, this constraint becomes trivial after we propagate the expected type
           (list name), and we have to solve (list name) =?= (list ?m)
        */
        type_context_old::full_postponed_scope scope(m_ctx, false);
        flet<bool> dont_recover(m_recover_from_errors, false);
        first_pass(fn, args, *expected_type, ref, info);
    } catch (elaborator_exception & ex1) {
        C.restore(*this);
        try {
            return visit_base_app_simple(fn, amask, args, args_already_visited, expected_type, ref);
        } catch (elaborator_exception & ex2) {
            throw nested_elaborator_exception(ref, std::current_exception(),
                                              format("switched to simple application elaboration procedure because "
                                                     "failed to use expected type to elaborate it, "
                                                     "error message") + nest(get_pp_indent(m_opts), line() + ex1.pp()));
        }
    }
    return second_pass(fn, args, ref, info);
}

expr elaborator::visit_base_app(expr const & fn, arg_mask amask, buffer<expr> const & args,
                                optional<expr> const & expected_type, expr const & ref) {
    return visit_base_app_core(fn, amask, args, false, expected_type, ref);
}

expr elaborator::visit_overload_candidate(expr const & fn, buffer<expr> const & args,
                                          optional<expr> const & expected_type, expr const & ref) {
    return visit_base_app_core(fn, arg_mask::Default, args, true, expected_type, ref);
}

format elaborator::mk_no_overload_applicable_msg(buffer<expr> const & fns, buffer<elaborator_exception> const & error_msgs) {
    format r("none of the overloads are applicable");
    lean_assert(error_msgs.size() == fns.size());
    for (unsigned i = 0; i < fns.size(); i++) {
        if (i > 0) r += line();
        auto pp_fn = mk_pp_ctx();
        r += line() + format("error for") + space() + pp_overload(pp_fn, fns[i]);
        r += line() + error_msgs[i].pp();
    }
    return r;
}

expr elaborator::visit_overloaded_app_core(buffer<expr> const & fns, buffer<expr> const & args,
                                           optional<expr> const & expected_type, expr const & ref) {
    buffer<expr> new_args;
    for (expr const & arg : args) {
        new_args.push_back(visit(arg, none_expr()));
    }

    snapshot S(*this);

    buffer<pair<expr, snapshot>> candidates;
    buffer<elaborator_exception> error_msgs;
    for (expr const & fn : fns) {
        try {
            flet<bool> dont_recover(m_recover_from_errors, false);
            // Restore state
            S.restore(*this);
            bool has_args = !args.empty();
            expr new_fn   = visit_function(fn, has_args, has_args ? none_expr() : expected_type, ref);
            expr c        = visit_overload_candidate(new_fn, new_args, expected_type, ref);
            synthesize_type_class_instances();

            if (expected_type) {
                expr c_type = infer_type(c);
                if (ensure_has_type(c, c_type, *expected_type, ref)) {
                    candidates.emplace_back(c, snapshot(*this));
                } else {
                    throw elaborator_exception(ref, format("invalid overload, term") +
                            pp_type_mismatch(c, c_type, *expected_type));
                }
            } else {
                candidates.emplace_back(c, snapshot(*this));
            }
        } catch (elaborator_exception & ex) {
            error_msgs.push_back(ex);
        } catch (exception & ex) {
            error_msgs.push_back(elaborator_exception(ref, format(ex.what())));
        }
    }
    lean_assert(candidates.size() + error_msgs.size() == fns.size());

    if (candidates.empty()) {
        S.restore(*this);

        throw elaborator_exception(ref, mk_no_overload_applicable_msg(fns, error_msgs));
    } else if (candidates.size() > 1) {
        S.restore(*this);

        options new_opts = m_opts.update_if_undef(get_pp_full_names_name(), true);
        flet<options> set_opts(m_opts, new_opts);
        auto pp_fn = mk_pp_ctx();
        format r("ambiguous overload, possible interpretations");
        for (auto const & c : candidates) {
            r += pp_indent(pp_fn, c.first);
        }
        throw elaborator_exception(ref, r);
    } else {
        // Restore successful state
        candidates[0].second.restore(*this);
        return candidates[0].first;
    }
}

expr elaborator::visit_overloaded_app_with_expected(buffer<expr> const & fns, buffer<expr> const & args,
                                                    expr const & expected_type, expr const & ref) {
    snapshot S(*this);
    buffer<std::tuple<expr, snapshot, first_pass_info>> candidates;
    buffer<elaborator_exception> error_msgs;
    for (expr const & fn : fns) {
        try {
            flet<bool> dont_recover(m_recover_from_errors, false);
            // Restore state
            S.restore(*this);
            bool has_args = !args.empty();
            expr new_fn   = visit_function(fn, has_args, has_args ? none_expr() : some(expected_type), ref);
            first_pass_info info;
            first_pass(new_fn, args, expected_type, ref, info);
            candidates.emplace_back(new_fn, snapshot(*this), info);
        } catch (elaborator_exception & ex) {
            error_msgs.push_back(ex);
        } catch (exception & ex) {
            error_msgs.push_back(elaborator_exception(ref, format(ex.what())));
        }
    }

    if (candidates.empty()) {
        try {
            /* Failed to disambiguate using expected type, switch to basic */
            S.restore(*this);
            return visit_overloaded_app_core(fns, args, some_expr(expected_type), ref);
        } catch (elaborator_exception & ex) {
            auto pp_fn = mk_pp_ctx();
            format msg = format("switched to basic overload resolution where arguments are elaborated without "
                                "any information about the expected type, because failed to elaborate all candidates "
                                "using the expected type");
            msg += pp_indent(pp_fn, expected_type);
            msg += line() + format("this can happen because, for example, coercions were not considered in the process");
            msg += line() + mk_no_overload_applicable_msg(fns, error_msgs);
            throw nested_elaborator_exception(ref, std::current_exception(), msg);
        }
    }

    if (candidates.size() == 1) {
        // Restore successful state
        auto & c = candidates[0];
        expr fn = std::get<0>(c);
        std::get<1>(c).restore(*this);
        first_pass_info & info = std::get<2>(c);
        try {
            return second_pass(fn, args, ref, info);
        } catch (elaborator_exception & ex) {
            auto pp_fn = mk_pp_ctx();
            format msg = format("overload was disambiguated using expected type");
            msg += line() + pp_overloads(pp_fn, fns);
            msg += line() + format("the only applicable one seemed to be: ") + pp_overload(pp_fn, fn);
            msg += line();

            for (auto const & error_msg : error_msgs) {
                msg += line() + error_msg.pp();
            }

            throw nested_elaborator_exception(ref, std::current_exception(), msg);
        }
    }

    try {
        /* Failed to disambiguate using expected type, switch to basic */
        S.restore(*this);
        return visit_overloaded_app_core(fns, args, some_expr(expected_type), ref);
    } catch (elaborator_exception & ex) {
        auto pp_fn = mk_pp_ctx();
        format msg = format("switched to basic overload resolution where arguments are elaborated without "
                            "any information about the expected type because it failed to disambiguate "
                            "overload using the expected type");
        msg += pp_indent(pp_fn, expected_type);
        msg += line() + format("the following overloaded terms were applicable");
        for (auto const & c : candidates)
            msg += pp_indent(pp_fn, std::get<0>(c));
        throw nested_elaborator_exception(ref, std::current_exception(), msg);
    }
}

expr elaborator::visit_overloaded_app(buffer<expr> const & fns, buffer<expr> const & args,
                                      optional<expr> const & expected_type, expr const & ref) {
    trace_elab_detail(tout() << "overloaded application at " << pos_string_for(ref);
                      auto pp_fn = mk_pp_ctx();
                      tout() << pp_overloads(pp_fn, fns) << "\n";);
    if (expected_type) {
        return visit_overloaded_app_with_expected(fns, args, *expected_type, ref);
    } else {
        try {
            return visit_overloaded_app_core(fns, args, expected_type, ref);
        } catch (elaborator_exception & ex) {
            format msg = format("switched to basic overload resolution where arguments are elaborated without "
                                "any information about the expected type because expected type was not available");
            throw nested_elaborator_exception(ref, std::current_exception(), msg);
        }
    }
}

expr elaborator::visit_no_confusion_app(expr const & fn, buffer<expr> const & args, optional<expr> const & expected_type,
                                        expr const & ref) {
    name fn_name = const_name(fn);
    if (!expected_type) {
        throw elaborator_exception(ref, format("invalid '") + format(fn_name) + format ("' application, ") +
                                   format("elaborator has special support for no_confusion ") +
                                   format("but the expected type must be known"));
    }
    if (args.empty()) {
        throw elaborator_exception(ref,
                                   format("invalid occurrence of function '") + format(fn_name) +
                                   format ("', it must be applied to at least one argument (possible solution: use '@')"));
    }
    /* I.no_confusion functions have a type of the form

       Pi (params) (indices) (C : Type) (lhs rhs : I params indices) (H : lhs = rhs),
          I.no_confusion_type params indices C lhs rhs

       The type (I.no_confusion_type params indices C lhs rhs) is C if lhs and rhs are distinct constructors,
       and (Pi Hs, C) if they are the same constructor where Hs is a sequence of equalities.

       (C : Type) is the expected type.

       To make the elaborator more effective, we first elaborate the first explicit argument (i.e., args[0]) and obtain Heq,
       and create the fake pre-term

       (I.no_confusion _ ... _ (as-is expected_type) _ _ (as-is Heq) args[1] ... args[n-1])

       Then, we elaborate this new fake pre-term.
    */
    expr Heq      = strict_visit(args[0], none_expr());
    name I_name   = fn_name.get_prefix();
    inductive_val I_val  = m_env.get(I_name).to_inductive_val();
    unsigned nparams     = I_val.get_nparams();
    unsigned nindices    = I_val.get_nindices();
    buffer<expr> new_args;
    for (unsigned i = 0; i < nparams + nindices; i++) {
        new_args.push_back(copy_pos(ref, mk_expr_placeholder()));
    }
    new_args.push_back(copy_pos(ref, mk_as_is(*expected_type)));
    new_args.push_back(copy_pos(ref, mk_expr_placeholder())); // lhs
    new_args.push_back(copy_pos(ref, mk_expr_placeholder())); // rhs
    new_args.push_back(copy_pos(args[0], mk_as_is(Heq)));
    for (unsigned i = 1; i < args.size(); i++)
        new_args.push_back(args[i]);
    return visit_base_app_core(fn, arg_mask::AllExplicit, new_args, false, expected_type, ref);
}

expr elaborator::visit_app_core(expr fn, buffer<expr> const & args, optional<expr> const & expected_type,
                                expr const & ref) {
    arg_mask amask = arg_mask::Default;
    expr ufn = unwrap_pos(fn);
    if (is_explicit(ufn)) {
        fn   = get_explicit_arg(ufn);
        amask = arg_mask::AllExplicit;
    } else if (is_partial_explicit(ufn)) {
        fn   = get_partial_explicit_arg(ufn);
        amask = arg_mask::InstHoExplicit;
    }

    bool has_args = !args.empty();

    expr orig_fn = fn;
    fn = unwrap_pos(fn);
    while (is_annotation(fn))
        fn = get_annotation_arg(fn);

    if (is_choice(fn)) {
        buffer<expr> fns;
        if (amask != arg_mask::Default) {
            format fmt = format("invalid explicit annotation because of overloading (possible solution: use fully qualified names) ");
            for (unsigned i = 0; i < get_num_choices(fn); i++)
                fns.push_back(get_choice(fn, i));
            auto pp_fn = mk_pp_ctx();
            fmt += pp_overloads(pp_fn, fns);
            throw elaborator_exception(ref, fmt);
        }
        for (unsigned i = 0; i < get_num_choices(fn); i++) {
            expr const & fn_i = get_choice(fn, i);
            fns.push_back(fn_i);
        }
        validate_overloads(fns, ref);
        return visit_overloaded_app(fns, args, expected_type, ref);
    } else if (is_field_notation(fn) && amask == arg_mask::Default) {
        expr s           = visit(mdata_expr(fn), none_expr());
        expr s_type      = head_beta_reduce(instantiate_mvars(infer_type(s)));
        auto field_res   = find_field_fn(fn, s, s_type);
        expr proj, proj_type;
        if (field_res.m_ldecl) {
            proj      = copy_pos(fn, field_res.m_ldecl->mk_ref());
            proj_type = field_res.m_ldecl->get_type();
        } else {
            proj      = copy_pos(fn, mk_constant(field_res.get_full_fname()));
            proj_type = m_env.get(field_res.get_full_fname()).get_type();
        }
        buffer<expr> new_args;
        unsigned i       = 0;
        while (is_pi(proj_type)) {
            if (is_explicit(binding_info(proj_type))) {
                if (is_app_of(extract_mdata(binding_domain(proj_type)), field_res.m_base_S_name)) {
                    /* found s location */
                    expr coerced_s = *mk_base_projections(m_env, field_res.m_S_name, field_res.m_base_S_name, mk_as_is(s));
                    new_args.push_back(copy_pos(fn, std::move(coerced_s)));
                    for (; i < args.size(); i++)
                        new_args.push_back(args[i]);
                    expr new_proj = visit_function(proj, has_args, has_args ? none_expr() : expected_type, ref);
                    return visit_base_app(new_proj, amask, new_args, expected_type, ref);
                } else {
                    if (i >= args.size()) {
                        throw elaborator_exception(ref, sstream() << "invalid field notation, insufficient number of arguments for '"
                                                   << field_res.get_full_fname() << "'");
                    }
                    new_args.push_back(args[i]);
                    i++;
                }
            }
            proj_type = binding_body(proj_type);
        }
        throw elaborator_exception(ref, sstream() << "invalid field notation, function '"
                                   << field_res.get_full_fname() << "' does not have explicit argument with type ("
                                   << field_res.m_base_S_name << " ...)");
    } else {
        expr new_fn = visit_function(fn, has_args, has_args ? none_expr() : expected_type, orig_fn);
        /* Check if we should use a custom elaboration procedure for this application. */
        if (is_constant(new_fn) && amask == arg_mask::Default) {
            if (auto info = use_elim_elab(const_name(new_fn))) {
                if (args.size() >= info->m_nexplicit) {
                    return visit_elim_app(new_fn, *info, args, expected_type, ref);
                } else {
                    try {
                        return visit_base_app(new_fn, amask, args, expected_type, ref);
                    } catch (elaborator_exception & ex) {
                        throw nested_elaborator_exception(ref, std::current_exception(),
                                                          format("'eliminator' elaboration was not used for '") +
                                                          pp(fn) + format("' because it is not fully applied, #") +
                                                          format(info->m_nexplicit) + format(" explicit arguments expected"));
                    }
                }
            } else if (is_no_confusion(m_env, const_name(new_fn))) {
                return visit_no_confusion_app(new_fn, args, expected_type, ref);
            } else {
                try {
                    return visit_base_app(new_fn, amask, args, expected_type, ref);
                } catch (elaborator_exception & ex) {
                    if (auto error_msg = m_elim_failure_info.find(const_name(new_fn))) {
                        throw nested_elaborator_exception(ref, std::current_exception(), *error_msg);
                    } else {
                        throw;
                    }
                }
            }
        }
        return visit_base_app(new_fn, amask, args, expected_type, ref);
    }
}

expr elaborator::visit_local(expr const & e, optional<expr> const & expected_type) {
    return visit_app_core(e, buffer<expr>(), expected_type, e);
}

expr elaborator::visit_constant(expr const & e, optional<expr> const & expected_type) {
    return visit_app_core(e, buffer<expr>(), expected_type, e);
}

expr elaborator::visit_scope_trace(expr const & e, optional<expr> const & expected_type) {
    buffer<expr> new_args;
    auto pip = get_pos_info_provider();
    unsigned line = 0, col = 0;
    if (pip) {
        pos_info pos = pip->get_pos_info_or_some(e);
        line         = pos.first;
        col          = pos.second;
    }
    new_args.push_back(copy_pos(e, mk_expr_placeholder()));
    new_args.push_back(copy_pos(e, mk_prenum(mpz(line))));
    new_args.push_back(copy_pos(e, mk_prenum(mpz(col))));
    new_args.push_back(app_arg(e));
    return visit(mk_app(copy_pos(e, mk_explicit(app_fn(e))), new_args.size(), new_args.data()), expected_type);
}

expr elaborator::visit_app(expr const & e, optional<expr> const & expected_type) {
    if (is_app_of(e, get_scope_trace_name(), 1))
        return visit_scope_trace(e, expected_type);
    buffer<expr> args;
    expr const & fn = get_app_args(e, args);
    flet<optional<pos_info>> _(m_last_pos, get_pos(fn));
    expr ufn = unwrap_pos(fn);
    if (is_infix_function(ufn)) {
        expr infix_fn = get_annotation_arg(ufn);
        lean_assert(is_lambda(infix_fn));
        return visit(head_beta_reduce(copy_pos(e, mk_app(infix_fn, args))), expected_type);
    } else if (is_equations(ufn)) {
        return visit_convoy(e, expected_type);
    } else {
        return visit_app_core(fn, args, expected_type, e);
    }
}

expr elaborator::visit_anonymous_constructor(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_anonymous_constructor(e));
    buffer<expr> args;
    expr const & c = get_app_args(get_anonymous_constructor_arg(e), args);
    if (!expected_type)
        throw elaborator_exception(e, "invalid constructor ⟨...⟩, expected type must be known");
    expr I = get_app_fn(m_ctx.relaxed_whnf(instantiate_mvars(*expected_type)));
    if (!is_constant(I))
        throw elaborator_exception(e, format("invalid constructor ⟨...⟩, expected type is not an inductive type") +
                                   pp_indent(*expected_type));
    name I_name = const_name(I);
    if (is_private(I_name) && !is_expr_aliased(m_env, I_name))
        throw elaborator_exception(e, "invalid constructor ⟨...⟩, type is a private inductive datatype");
    constant_info I_info = m_env.get(I_name);
    if (!I_info.is_inductive())
        throw elaborator_exception(e, sstream() << "invalid constructor ⟨...⟩, '" << I_name << "' is not an inductive type");
    names c_names = I_info.to_inductive_val().get_cnstrs();
    if (!c_names || tail(c_names))
        throw elaborator_exception(e, sstream() << "invalid constructor ⟨...⟩, '" << I_name << "' must have only one constructor");
    expr type = m_env.get(head(c_names)).get_type();
    unsigned num_explicit = 0;
    while (is_pi(type)) {
        if (is_explicit(binding_info(type)))
            num_explicit++;
        type = binding_body(type);
    }
    if (num_explicit > 1 && args.size() > num_explicit) {
        unsigned num_extra = args.size() - num_explicit;
        expr rest = copy_pos(e, mk_app(c, num_extra + 1, args.data() + num_explicit - 1));
        rest = copy_pos(e, mk_anonymous_constructor(rest));
        args.shrink(num_explicit);
        args.back() = rest;
    }
    expr new_e = copy_pos(e, mk_app(mk_constant(head(c_names)), args));
    return visit(new_e, expected_type);
}

static expr get_equations_fn_type(expr const & eqns) {
    buffer<expr> eqs;
    to_equations(eqns, eqs);
    lean_assert(!eqs.empty());
    lean_assert(is_lambda(eqs[0]));
    return binding_domain(eqs[0]);
}

/** \brief Similar to instantiate_rev, but assumes that subst contains only local constants.
    When replacing a variable with a local, we copy the local constant and inherit the tag
    associated with the variable. This is a trick for preserving position information. */
static expr instantiate_rev_locals(expr const & a, unsigned n, expr const * subst) {
    if (!has_loose_bvars(a))
        return a;
    auto fn = [=](expr const & m, unsigned offset) -> optional<expr> {
        if (offset >= get_loose_bvar_range(m))
            return some_expr(m); // expression m does not contain free variables with idx >= offset
        if (is_var(m)) {
            unsigned vidx = bvar_idx(m).get_small_value();
            if (vidx >= offset) {
                unsigned h = offset + n;
                if (h < offset /* overflow, h is bigger than any vidx */ || vidx < h) {
                    expr local = subst[n - (vidx - offset) - 1];
                    lean_assert(is_local(local));
                    return some_expr(copy_pos(m, copy(local)));
                } else {
                    return some_expr(copy_pos(m, mk_bvar(vidx - n)));
                }
            }
        }
        return none_expr();
    };
    return replace(a, fn);
}

static expr instantiate_rev_locals(expr const & e, type_context_old::tmp_locals const & locals) {
    return instantiate_rev_locals(e, locals.as_buffer().size(), locals.as_buffer().data());
}

static expr update_equations_fn_type(expr const & eqns, expr const & new_fn_type) {
    expr fn_type = mk_as_is(new_fn_type);
    buffer<expr> eqs;
    to_equations(eqns, eqs);
    for (expr & eq : eqs) {
        lean_assert(is_lambda(eq));
        eq = update_binding(eq, fn_type, binding_body(eq));
    }
    return update_equations(eqns, eqs);
}

expr elaborator::visit_convoy(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_app(e));
    lean_assert(is_equations(unwrap_pos(get_app_fn(e))));
    expr const & ref = e;
    buffer<expr> args, new_args;
    expr eqns = unwrap_pos(get_app_args(e, args));
    lean_assert(equations_num_fns(eqns) == 1);
    lean_assert(equations_size(eqns) > 0);
    expr fn_type = get_equations_fn_type(eqns);
    expr new_fn_type;
    if (is_placeholder(fn_type)) {
        /* User did not provide the type for the match,
           we try to infer one using expected_type and the type of the arguments */
        if (!expected_type)
            throw elaborator_exception(ref, "invalid match/convoy expression, expected type is not known");
        for (unsigned i = 0; i < args.size(); i++)
            new_args.push_back(visit(args[i], none_expr()));
        synthesize();
        new_fn_type = instantiate_mvars(*expected_type);
        unsigned i = args.size();
        while (i > 0) {
            --i;
            expr new_arg      = instantiate_mvars(new_args[i]);
            expr new_arg_type = instantiate_mvars(infer_type(new_arg));
            new_fn_type       = ::lean::mk_pi("_a", new_arg_type, kabstract(m_ctx, new_fn_type, new_arg));
        }
        try {
            check(m_ctx, new_fn_type);
        } catch (exception & ex) {
            throw nested_exception("invalid match/convoy expression, "
                                   "user did not provide type for the expression, "
                                   "lean tried to infer one using expected type information, "
                                   "but result is not type correct", std::current_exception());
        }
    } else {
        // User provided some typing information for the match
        type_context_old::tmp_locals locals(m_ctx);
        expr it = fn_type;
        for (unsigned i = 0; i < args.size(); i++) {
            it = unwrap_pos(it);
            if (!is_pi(it))
                throw elaborator_exception(it, "type expected in match-expression");
            expr d        = instantiate_rev_locals(binding_domain(it), locals);
            expr new_d    = visit(d, none_expr());
            expr ref_d    = get_ref_for_child(binding_domain(it), it);
            new_d         = ensure_type(new_d, ref_d);
            expr expected = replace_locals(new_d, locals.as_buffer(), new_args);
            expr new_arg  = visit(args[i], some_expr(expected));
            new_arg       = enforce_type(new_arg, expected, "type mismatch in match expression", args[i]);
            locals.push_local(binding_name(it), new_d, binding_info(it));
            it            = binding_body(it);
            new_args.push_back(new_arg);
        }
        if (is_placeholder(it)) {
            synthesize();
            if (!expected_type)
                throw elaborator_exception(ref, "invalid match/convoy expression, expected type is not known");
            new_fn_type = instantiate_mvars(*expected_type);
            unsigned i = args.size();
            while (i > 0) {
                --i;
                new_args[i]  = instantiate_mvars(new_args[i]);
                new_fn_type  = instantiate(kabstract(m_ctx, new_fn_type, new_args[i]), locals.as_buffer()[i]);
            }
            new_fn_type = locals.mk_pi(new_fn_type);
        } else {
            expr b      = instantiate_rev_locals(it, locals);
            expr new_b  = visit(b, none_expr());
            synthesize();
            new_fn_type = locals.mk_pi(instantiate_mvars(new_b));
        }
    }
    new_fn_type = instantiate_mvars(new_fn_type);
#if 0
    /* The following check is too restrictive in do blocks. */
    if (has_expr_metavar(new_fn_type)) {
        auto pp_fn = mk_pp_ctx();
        throw elaborator_exception(ref, format("invalid match/convoy expression, type contains meta-variables") +
                                   pp_indent(pp_fn, new_fn_type));
    }
#endif
    trace_elab(tout() << "match/convoy function type: " << new_fn_type << "\n";);
    expr new_eqns = visit_equations(update_equations_fn_type(eqns, new_fn_type));
    expr fn       = get_equations_result(new_eqns, 0);
    return mk_app(fn, new_args);
}

/** \brief Given two binding expressions \c source and \c target
    s.t. they have at least \c num binders, replace the first \c num binders of \c target with \c source.
    The binder types are wrapped with \c mk_as_is to make sure the elaborator will not process
    them again. */
static expr copy_domain(unsigned num, expr const & source, expr const & target) {
    if (num == 0) {
        return target;
    } else if (is_binding(source) && is_binding(target)) {
        return update_binding(source, mk_as_is(binding_domain(source)),
                              copy_domain(num-1, binding_body(source), binding_body(target)));
    } else {
        return target;
    }
}

static void throw_ill_formed_equation(expr const & ref) {
    throw elaborator_exception(ref, "ill-formed match/equation expression");
}

static void check_equations_arity(buffer<expr> const & eqns) {
    buffer<optional<unsigned>> fidx2arity;
    for (expr eqn : eqns) {
        unsigned nbinders = 0;
        expr curr = eqn;
        while (is_lambda(eqn)) {
            nbinders++;
            eqn = binding_body(eqn);
        }
        if (is_equation(eqn)) {
            expr const & lhs = equation_lhs(eqn);
            expr const & fn  = get_app_fn(lhs);
            unsigned arity   = get_app_num_args(lhs);
            if (!is_var(fn) || bvar_idx(fn) >= nbinders)
                throw_ill_formed_equation(eqn);
            unsigned fidx    = nbinders - bvar_idx(fn).get_small_value() - 1;
            if (fidx >= fidx2arity.size())
                fidx2arity.resize(fidx+1, optional<unsigned>());
            if (auto r = fidx2arity[fidx]) {
                if (*r != arity) {
                    throw elaborator_exception(eqn, "invalid match/equations expression, "
                                               "each case must have the same number of patterns");
                }
            } else {
                fidx2arity[fidx] = arity;
            }
        } else if (is_no_equation(eqn)) {
            /* do nothing */
        } else {
            throw_ill_formed_equation(curr);
        }
    }
}

bool elaborator::keep_do_failure_eq(expr const & first_eq) {
    if (!is_lambda(first_eq))
        return false; // possible with error recovery
    expr type = binding_domain(first_eq);
    if (!is_pi(type))
        return false;
    type = binding_body(type);
    if (has_loose_bvars(type))
        return false;
    return is_app(type) && is_monad_fail(app_fn(type));
}

expr elaborator::mk_aux_meta_def(expr const & e, expr const & ref) {
    name aux_name(m_decl_name, "_aux_meta");
    aux_name = aux_name.append_after(m_aux_meta_idx);
    m_aux_meta_idx++;
    expr new_c;
    metavar_context mctx = m_ctx.mctx();
    std::tie(m_env, new_c) = mk_aux_definition(m_env, mctx, local_context(),
                                               aux_name, e, optional<bool>(true));
    if (!is_constant(new_c)) {
        throw elaborator_exception(ref, "failed to create auxiliary definition");
    }
    m_env = compile(m_env, m_opts, const_name(new_c));
    m_ctx.set_env(m_env);
    m_ctx.set_mctx(mctx);
    return new_c;
}

static void mvar_dep_sort_aux(type_context_old & ctx, expr const & m,
                              name_set const & mvar_names, name_set & visited, buffer<expr> & result) {
    if (visited.contains(mvar_name(m)))
        return;
    for_each(ctx.instantiate_mvars(ctx.infer(m)), [&](expr const & e, unsigned) {
            if (is_mvar(e) && mvar_names.contains(mvar_name(e))) {
                mvar_dep_sort_aux(ctx, e, mvar_names, visited, result);
                return false; // do not visit types
            }
            if (is_local(e)) {
                return false; // do not visit types
            }
            return true;
        });
    visited.insert(mvar_name(m));
    result.push_back(m);
}

/* Topological sort based on dependencies. */
static void mvar_dep_sort(type_context_old & ctx, buffer<expr> & mvars) {
    name_set visited;
    buffer<expr> result;
    name_set mvar_names;
    for (expr const & m : mvars)
        mvar_names.insert(mvar_name(m));
    for (expr const & m : mvars)
        mvar_dep_sort_aux(ctx, m, mvar_names, visited, result);
    mvars.clear();
    mvars.append(result);
}

/* We preprocess the equation left-hand-side by first elaborating it using metavariables.
   This process allows us to refine pattern variables whose value is fixed by type inference.
   Before processing the right-hand-side, we must convert back these metavariables into
   pattern variables (i.e., local constants).
   This visitor collects metavariables that must be converted into pattern variables, and
   validates the equation left-hand-side. It returns the input expression expanded to
   expose its primitive patterns. */
class validate_and_collect_lhs_mvars : public replace_visitor {
    elaborator &    m_elab;
    bool            m_has_invalid_pattern = false;
    expr            m_ref;
    /* m_mctx0 is the metavariable context before processing the equation.
       Only metavariables created when processing the equation can be
       converted into pattern variables. */
    metavar_context m_mctx0;
    buffer<expr> &  m_unassigned_mvars;
    name_set        m_collected;

    type_context_old & ctx() { return m_elab.m_ctx; }

    environment const & env() { return m_elab.env(); }

    optional<expr> expand(expr const & e) {
        /* We don't simply use whnf because we want to avoid exposing the internal implementation
           of definitions compiled using the equation compiler */
        {
            /* Try without use delta reduction */
            type_context_old::transparency_scope scope(ctx(), transparency_mode::None);
            expr new_e = ctx().whnf(e);
            if (new_e != e) return some_expr(new_e);
        }
        if (auto new_e = ctx().reduce_projection(e))
            return new_e;
        // HACK: trying to delete `dunfold`
        // /* Try to unfold using refl equations */
        // if (auto new_e = dunfold(ctx(), e))
        // return new_e;
        /* Last resort, whnf using current setting */
        expr new_e = ctx().whnf(e);
        if (new_e != e) return some_expr(new_e);
        return none_expr();
    }

    void throw_invalid_pattern(char const * msg, expr const & e) {
        m_elab.report_or_throw(
            elaborator_exception(m_ref, format(msg)
                + format(" (possible solution, mark term as inaccessible using '.( )')")
                + m_elab.pp_indent(e))
            .ignore_if(m_elab.has_synth_sorry(e)));
        m_has_invalid_pattern = true;
    }

    virtual expr visit_local(expr const & e) override {
        return e;
    }

    virtual expr visit_lambda(expr const & e) override {
        throw_invalid_pattern("invalid occurrence of lambda expression in pattern", e);
        return e;
    }

    virtual expr visit_pi(expr const & e) override {
        throw_invalid_pattern("invalid occurrence of pi/forall expression in pattern", e);
        return e;
    }

    virtual expr visit_let(expr const & e) override {
        return visit(instantiate(let_body(e), let_value(e)));
    }

    virtual expr visit_sort(expr const & e) override {
        throw_invalid_pattern("invalid occurrence of sort in pattern", e);
        return e;
    }

    virtual expr visit_meta(expr const & m) override {
        if (is_metavar_decl_ref(m) && !m_mctx0.find_metavar_decl(m)) {
            if (!m_collected.contains(mvar_name(m))) {
                m_unassigned_mvars.push_back(m);
                m_collected.insert(mvar_name(m));
            }
            return m;
        } else {
            throw_invalid_pattern("invalid occurrence of metavariable in pattern", m);
            return m;
        }
    }

    void throw_invalid_app(expr const & e) {
        if (is_constant(e))
            throw_invalid_pattern("invalid constant in pattern, it cannot be reduced to a constructor", e);
        else
            throw_invalid_pattern("invalid function application in pattern, it cannot be reduced to a constructor", e);
    }

    virtual expr visit_app(expr const & e) override {
        expr it = e;
        while (true) {
            if (is_nat_int_char_string_name_value(ctx(), it))
                return e;
            if (!is_app(it) && !is_constant(it))
                return visit(it);
            buffer<expr> args;
            expr const & fn = get_app_args(it, args);
            if (!is_constant(fn)) {
                throw_invalid_app(e);
                return e;
            }

            constant_info fn_info = env().get(const_name(fn));
            if (fn_info.is_constructor()) {
                unsigned num_params = fn_info.to_constructor_val().get_nparams();
                for (unsigned i = num_params; i < args.size(); i++) {
                    visit(args[i]);
                }
                return e;
            } else {
                if (auto r = expand(it)) {
                    it = *r;
                } else {
                    throw_invalid_app(e);
                    return e;
                }
            }
        }
    }

    virtual expr visit_constant(expr const & e) override {
        return visit_app(e);
    }

    virtual expr visit_mdata(expr const & e) override {
        if (is_inaccessible(e)) {
            return e;
        } else if (is_as_pattern(e)) {
            expr new_lhs = visit(get_as_pattern_lhs(e));
            expr new_rhs = visit(get_as_pattern_rhs(e));
            return mk_as_pattern(new_lhs, new_rhs);
        } else if (is_structure_instance(e)) {
            auto info = get_structure_instance_info(e);
            if (info.m_sources.size())
                throw elaborator_exception(info.m_sources[0], "invalid occurrence of structure notation source in pattern");
            for (expr & val : info.m_field_values)
                val = visit(val);
            return mk_structure_instance(info);
        } else {
            return visit(mdata_expr(e));
        }
    }

public:
    validate_and_collect_lhs_mvars(elaborator & elab, expr const & ref, metavar_context const & mctx0,
                                   buffer<expr> & unassigned_mvars):
        m_elab(elab),
        m_ref(ref),
        m_mctx0(mctx0),
        m_unassigned_mvars(unassigned_mvars) {
    }

    bool operator()(expr const & lhs) {
        buffer<expr> args;
        get_app_args(lhs, args);
        for (expr & arg : args)
            visit(arg);
        return m_has_invalid_pattern;
    }
};

/* Similar to instantiate_mvars, but add an inaccessible pattern annotation around metavariables
   whose value has been fixed by type inference. */
static expr instantiate_pattern_mvars(type_context_old & ctx, expr const & lhs) {
    return replace(lhs, [&](expr const & e, unsigned) {
            if (is_metavar_decl_ref(e) && ctx.is_assigned(e)) {
                expr v = ctx.instantiate_mvars(e);
                if (!is_local(v) && !is_metavar(v))
                    return some_expr(copy_pos(e, mk_inaccessible(v)));
                else
                    return some_expr(v);
            } else {
                return none_expr();
            }
        });
}

expr elaborator::visit_equation(expr const & e, unsigned num_fns) {
    expr const & ref = e;
    type_context_old::tmp_locals fns(m_ctx);
    expr it = e;
    for (unsigned i = 0; i < num_fns; i++) {
        if (!is_lambda(it))
            throw_ill_formed_equation(ref);
        expr d     = instantiate_rev_locals(binding_domain(it), fns);
        expr new_d = visit(d, none_expr());
        expr ref_d = get_ref_for_child(binding_domain(it), it);
        expr fn    = push_local(fns, binding_name(it), new_d, binding_info(it), ref_d);
        it = binding_body(it);
    }
    if (is_no_equation(it)) {
        return fns.mk_lambda(it);
    } else {
        trace_elab_equation(tout() << "visit_equation\n";);
        metavar_context mctx0 = m_ctx.mctx();
        it = instantiate_rev_locals(it, fns);
        buffer<expr> local_mvars;
        buffer<expr> type_mvars;
        while (is_lambda(it)) {
            expr type = mk_type_metavar(it);
            type_mvars.push_back(type);
            expr mvar = m_ctx.mk_metavar_decl(binding_name(it), m_ctx.lctx(), type);
            local_mvars.push_back(mvar);
            it = binding_body(it);
        }
        if (!is_equation(it))
            throw_ill_formed_equation(ref);
        expr lhs    = instantiate_rev(equation_lhs(it), local_mvars);
        expr lhs_fn = get_app_fn(lhs);
        if (is_explicit_or_partial_explicit(lhs_fn))
            lhs_fn = get_explicit_or_partial_explicit_arg(lhs_fn);
        if (!is_local_p(lhs_fn))
            throw_ill_formed_equation(ref);
        expr new_lhs;
        {
            flet<bool> set(m_in_pattern, true);
            flet<bool> dont_recover(m_recover_from_errors, false);
            /* Note that pattern elaboration is more sensitive than standard elaboration:
             * mvars in `new_lhs` will be turned into pattern variables below, so care must be taken when instantiating
             * or introducing them. See the very end of `visit_structure_instance` for an example. */
            new_lhs = visit(lhs, none_expr());
            synthesize();
        }
        trace_elab_equation(tout() << "new_lhs:\n" << new_lhs << "\n";);
        new_lhs = instantiate_pattern_mvars(m_ctx, new_lhs);
        trace_elab_equation(tout() << "new_lhs (after instantiate_pattern_mvars):\n" << new_lhs << "\n";);
        // collect unassigned metavariables not in mctx0
        buffer<expr> unassigned_mvars;
        validate_and_collect_lhs_mvars(*this, ref, mctx0, unassigned_mvars)(new_lhs);
        // sort using dependencies
        mvar_dep_sort(m_ctx, unassigned_mvars);
        // create local variables for each unassigned metavar
        type_context_old::tmp_locals new_locals(m_ctx);
        unsigned next_idx = 1;
        for (expr & m : unassigned_mvars) {
            expr type      = instantiate_mvars(m_ctx.infer(m));
            name user_name;
            if (optional<metavar_decl> mdecl = m_ctx.find_metavar_decl(m)) {
                user_name = mdecl->get_user_name();
            } else {
                user_name = name("_x").append_after(next_idx);
                next_idx++;
            }
            expr new_local = new_locals.push_local(user_name, type, mk_binder_info());
            m_ctx.assign(m, new_local);
        }
        // replace metavariables with new locals
        new_lhs           = instantiate_mvars(new_lhs);
        expr new_lhs_type = instantiate_mvars(infer_type(new_lhs));
        // process rhs
        buffer<expr> rhs_subst;
        for (expr const & local_mvar : local_mvars) {
            expr s = instantiate_mvars(local_mvar);
            if (!is_local(s)) {
                /* The `as_is` annotation affects how applications are elaborated.
                   See comment at first_pass method.
                   So, we only use it if it is really needed. That is,
                   the metavariable was fixed to a non trivial term by type inference rules.
                   For example, in the following definition

                   ```
                   inductive Vec (A : Type) : nat → Type
                   | nil {} : Vec 0
                   | cons   : Π {n}, A → Vec n → Vec (succ n)

                   open Vec

                   def append1 {A : Type} : Π {m n : nat}, Vec A m -> Vec A n -> Vec A (n + m)
                   | n m nil         ys := ys
                   | n m (cons x xs) ys := cons x (append1 xs ys)
                   ```

                   The variable n is refined to 0 and (succ n') in the first and second equations.
                */
                s = mk_as_is(s);
            }
            rhs_subst.push_back(s);
        }
        expr rhs     = instantiate_rev(equation_rhs(it), rhs_subst);
        expr new_rhs = visit(rhs, some_expr(new_lhs_type));
        // synthesize();
        // new_rhs       = instantiate_mvars(new_rhs);
        new_rhs       = enforce_type(new_rhs, new_lhs_type, "equation type mismatch", it);
        expr new_eq = copy_pos(it, mk_equation(new_lhs, new_rhs, ignore_equation_if_unused(it)));
        trace_elab_equation(tout() << new_eq << "\n";);
        expr r = copy_pos(ref, fns.mk_lambda(new_locals.mk_lambda(new_eq)));
        return r;
    }
}

expr elaborator::visit_equations(expr const & e) {
    expr const & ref = e;
    buffer<expr> eqs;
    buffer<expr> new_eqs;
    optional<expr> new_tacs;
    equations_header const & header = get_equations_header(e);
    unsigned num_fns = header.m_num_fns;
    to_equations(e, eqs);
    lean_assert(!eqs.empty());

    if (is_wf_equations(e)) {
        expr type = mk_constant(get_well_founded_tactics_name());
        new_tacs  = visit(equations_wf_tactics(e), some_expr(type));
        new_tacs  = enforce_type(*new_tacs, type, "well_founded_tactics object expected", ref);
        if (!is_constant(*new_tacs)) {
            new_tacs = mk_aux_meta_def(*new_tacs, ref);
        }
    }

    optional<expr> first_eq;
    for (expr const & eq : eqs) {
        expr new_eq;
        if (first_eq) {
            if (is_do_failure_eq(eq) && !keep_do_failure_eq(*first_eq)) {
                /* skip equation since it doesn't implement the monad_fail interface */
            } else {
                /* Replace first num_fns domains of eq with the ones in first_eq.
                   This is a trick/hack to ensure the fns in each equation have
                   the same elaborated type. */
                new_eq   = copy_pos(eq, visit_equation(copy_domain(num_fns, *first_eq, eq), num_fns));
                new_eqs.push_back(new_eq);
            }
        } else {
            new_eq   = copy_pos(eq, visit_equation(eq, num_fns));
            first_eq = new_eq;
            new_eqs.push_back(new_eq);
        }
    }
    check_equations_arity(new_eqs);
    synthesize();
    expr new_e;
    if (new_tacs) {
        new_e = copy_pos(e, mk_equations(header, new_eqs.size(), new_eqs.data(), *new_tacs));
    } else {
        new_e = copy_pos(e, mk_equations(header, new_eqs.size(), new_eqs.data()));
    }
    new_e = instantiate_mvars(new_e);
    ensure_no_unassigned_metavars_core(new_e);
    if (has_sorry(new_e))
        // aborting here prevents many additional errors
        throw elaborator_exception(e, "[abort visit_equation]").ignore_if(true);
    if (!has_synth_sorry(new_e) && has_expr_metavar(e)) {
        /* We perform this check to be able to reject code such as:
           ```
           @[pattern] def badPattern (x : Nat) : Nat := 0
           def tst (x : Nat) : Nat :=
           match x with
           | (@badPattern _) := 1
           | _               := 2
           ```
        */
        // TODO(Leo, Kha): enable the following check
        // throw elaborator_exception(new_e, "invalid pattern");
    }
    metavar_context mctx = m_ctx.mctx();
    expr r = compile_equations(m_env, *this, mctx, m_ctx.lctx(), new_e);
    m_ctx.set_env(m_env);
    m_ctx.set_mctx(mctx);
    return r;
}

expr elaborator::visit_inaccessible(expr const & e, optional<expr> const & expected_type) {
    if (!m_in_pattern)
        throw elaborator_exception(e, "invalid occurrence of 'inaccessible' annotation, "
                                   "it must only occur in patterns");
    expr a = get_annotation_arg(e);
    expr new_a;
    {
        flet<bool> set(m_in_pattern, false);
        new_a = visit(a, expected_type);
    }
    return copy_pos(e, mk_inaccessible(new_a));
}

elaborator::field_resolution elaborator::field_to_decl(expr const & e, expr const & s, expr const & s_type) {
    // prefer 'unknown identifier' error when lhs is a constant of non-value type
    if (is_field_notation(e)) {
        auto lhs = unwrap_pos(mdata_expr(e));
        if (is_constant(lhs)) {
            type_context_old::tmp_locals locals(m_ctx);
            expr t = whnf(s_type);
            while (is_pi(t)) {
                t = whnf(instantiate(binding_body(t), locals.push_local_from_binding(t)));
            }
            if (is_sort(t) && !is_anonymous_field_notation(e)) {
                name fname = get_field_notation_field_name(e);
                throw elaborator_exception(lhs, format("unknown identifier '") + format(const_name(lhs)) + format(".") +
                                           format(fname) + format("'"));
            }
        }
    }
    expr I      = get_app_fn(s_type);
    if (!is_constant(I)) {
        auto pp_fn = mk_pp_ctx();
        throw elaborator_exception(e, format("invalid field notation, type is not of the form (C ...) where C is a constant") +
                                   pp_indent(pp_fn, s) +
                                   line() + format("has type") +
                                   pp_indent(pp_fn, s_type));
    }
    if (is_anonymous_field_notation(e)) {
        if (!is_structure(m_env, const_name(I))) {
            auto pp_fn = mk_pp_ctx();
            throw elaborator_exception(e, format("invalid projection, structure expected") +
                                       pp_indent(pp_fn, s) +
                                       line() + format("has type") +
                                       pp_indent(pp_fn, s_type));
        }
        auto fnames = get_structure_fields(m_env, const_name(I));
        unsigned fidx = get_field_notation_field_idx(e);
        if (fidx  == 0) {
            throw elaborator_exception(e, "invalid projection, index must be greater than 0");
        }
        if (fidx > fnames.size()) {
            auto pp_fn = mk_pp_ctx();
            throw elaborator_exception(e, format("invalid projection, structure has only ") +
                                       format(fnames.size()) + format(" field(s)") +
                                       pp_indent(pp_fn, s) +
                                       line() + format("which has type") +
                                       pp_indent(pp_fn, s_type));
        }
        return const_name(I) + fnames[fidx-1];
    } else {
        name fname  = get_field_notation_field_name(e);
        // search for "true" fields first, including in parent structures
        if (is_structure_like(m_env, const_name(I)))
            if (auto p = find_field(m_env, const_name(I), fname))
                return field_resolution(const_name(I), *p, fname);
        name full_fname = const_name(I) + fname;
        name local_name = full_fname.replace_prefix(get_namespace(env()), {});
        if (auto ldecl = m_ctx.lctx().find_if([&](local_decl const & decl) {
            return is_rec(decl.get_info()) && decl.get_user_name() == local_name;
        })) {
            // projection is recursive call
            return field_resolution(full_fname, ldecl);
        }
        if (!m_env.find(full_fname)) {
            auto pp_fn = mk_pp_ctx();
            throw elaborator_exception(e, format("invalid field notation, '") + format(fname) + format("'") +
                                       format(" is not a valid \"field\" because environment does not contain ") +
                                       format("'") + format(full_fname) + format("'") +
                                       pp_indent(pp_fn, s) +
                                       line() + format("which has type") +
                                       pp_indent(pp_fn, s_type));
        }
        return full_fname;
    }
}

elaborator::field_resolution elaborator::find_field_fn(expr const & e, expr const & s, expr const & s_type) {
    try {
        return field_to_decl(e, s, s_type);
    } catch (elaborator_exception & ex1) {
        expr new_s_type = s_type;
        if (auto d = unfold_term(env(), new_s_type))
            new_s_type = *d;
        new_s_type = m_ctx.whnf_head_pred(new_s_type, [](expr const &) { return false; });
        if (new_s_type == s_type)
            throw;
        std::exception_ptr ex1_ptr = std::current_exception();
        try {
            return find_field_fn(e, s, new_s_type);
        } catch (elaborator_exception & ex2) {
            throw nested_elaborator_exception(ex2.get_pos(), ex1_ptr, ex2.pp());
        }
    }
}

expr elaborator::visit_field(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_field_notation(e));
    expr s         = visit(mdata_expr(e), none_expr());
    expr s_type    = head_beta_reduce(instantiate_mvars(infer_type(s)));
    auto field_res = find_field_fn(e, s, s_type);
    expr proj_app;
    if (field_res.m_ldecl) {
        proj_app   = copy_pos(e, mk_app(field_res.m_ldecl->mk_ref(), mk_as_is(s)));
    } else {
        expr new_e = *mk_base_projections(m_env, field_res.m_S_name, field_res.m_base_S_name, mk_as_is(s));
        proj_app   = mk_proj_app(m_env, field_res.m_base_S_name, field_res.m_fname, new_e, e);
    }
    return visit(proj_app, expected_type);
}

class reduce_projections_visitor : public replace_visitor {
private:
    type_context_old & m_ctx;
protected:
    expr visit_app(expr const & e) override {
        expr e2 = replace_visitor::visit_app(e);
        if (has_metavar(e2)) {
            if (auto e3 = m_ctx.reduce_projection(e2))
                return *e3;
        }
        return e2;
    }
public:
    reduce_projections_visitor(type_context_old & ctx): m_ctx(ctx) {}
};

/* Predicated variant of `lean::instantiate_mvars`. It does not support universe mvars. */
expr elaborator::instantiate_mvars(expr const & e, std::function<bool(expr const &)> pred) { // NOLINT
    return replace(e, [&](expr const & e) {
        if (m_ctx.is_mvar(e) && pred(e))
            if (auto asn = m_ctx.get_assignment(e))
                return some_expr(instantiate_mvars(*asn, pred));
        return none_expr();
    });
}

/** Elaborate the structure instance notation `{... := ..., ...}` */
class visit_structure_instance_fn {
    // an elaborated source `..(m_e : m_S_name ...)`
    struct source {
        expr m_e;
        // known to be a structure
        name m_S_name;
    };

    elaborator & m_elab;
    // note: fields needed by trace macros
    environment & m_env = m_elab.m_env;
    type_context_old & m_ctx = m_elab.m_ctx;

    // inputs
    expr m_e, m_ref = m_e;
    optional<expr> m_expected_type;
    bool m_use_subobjects = !m_elab.m_opts.get_bool("old_structure_cmd", false);
    structure_instance_info m_info = get_structure_instance_info(m_e);
    name & m_S_name = m_info.m_struct_name;
    buffer<name> const & m_fnames = m_info.m_field_names;
    buffer<expr> const & m_fvalues = m_info.m_field_values;

    // set of fnames that have been used by `create_field_mvars`. Not using all of them is an error.
    name_set m_fnames_used;
    // fields for which no value could be found
    buffer<name> m_missing_fields;
    // elaborated sources
    buffer<source> m_sources;

    /* Because field default values may introduce arbitrary dependencies on other field values (not only within a structure,
     * but even between a structure and its parent structures, in either direction), we cannot elaborate fields in a static
     * order. Instead, we register a metavar and an elaboration function for each field (create_field_mvars).
     * We call the elaboration function and substitute the metavar with its result (insert_field_values)
     * only after all field metavars in its expected type have been resolved (reduce_and_check_dependencies). */

    // field -> elaboration function
    name_map<std::function<expr(expr const & expected_type)>> m_field2elab;
    // field <-> metavar for each field to be elaborated
    name_map<expr> m_field2mvar;
    name_map<name> m_mvar2field;

    bool field_from_source(name const & S_fname) {
        for (source const & src : m_sources) {
            if (optional<name> base_S_name = find_field(m_env, src.m_S_name, S_fname)) {
                expr base_src = *mk_base_projections(m_env, src.m_S_name, *base_S_name, src.m_e);
                expr f = mk_proj_app(m_env, *base_S_name, S_fname, base_src);
                m_field2elab.insert(S_fname, [=](expr const & d) {
                    return m_elab.visit(f, some_expr(d));
                });
                return true;
            }
        }
        return false;
    }

    struct field_not_ready_to_synthesize_exception : exception {
        std::function<format()> m_fmt;
        explicit field_not_ready_to_synthesize_exception(std::function<format()> m_fmt) : m_fmt(m_fmt) {}
    };

    void field_from_default_value(name const & S_fname) {
        m_field2elab.insert(S_fname, [=](expr const & d) {
            if (m_elab.m_in_pattern) {
                // insert placeholder during pattern elaboration
                return m_elab.mk_metavar(d, m_ref);
            } else {
                name full_S_fname = m_S_name + S_fname;
                expr pre_fval = mk_field_default_value(m_env, full_S_fname, [&](name const & fname) {
                    // just insert mvars for now, we will check for any uninstantiated ones in `reduce_and_check_deps` below
                    return m_field2mvar[fname];
                });
                expr fval = m_elab.visit(pre_fval, some_expr(d));
                /* Delta- and beta-reduce `_default` definition. This can remove dependencies when defaulting
                 * a field of a parent structure.
                 * For example, monad defaults applicative.seq in terms of map and bind. However, since map is part
                 * of the subobject to_applicative as well, we get the recursive constraint
                 * `?seq =?= monad.seq._default {to_functor := {map := ?map, ...}, seq := ?seq, ...} ?bind ...`
                 * Reducing monad.seq._default allows `reduce_and_check_deps` below to remove the ?seq dependency. */
                buffer<expr> args;
                expr fn = get_app_args(fval, args);
                if (is_constant(fn)) {
                    constant_info decl = m_env.get(const_name(fn));
                    expr default_val = instantiate_value_lparams(decl, const_levels(fn));
                    // clean up 'id' application inserted by `structure_cmd::declare_defaults`
                    default_val = replace(default_val, [](expr const & e) {
                        if (is_app_of(e, get_id_name(), 2)) {
                            return some_expr(app_arg(e));
                        }
                        return none_expr();
                    });
                    fval = mk_app(default_val, args);
                    fval = head_beta_reduce(fval);
                }
                reduce_and_check_deps(fval, full_S_fname);
                return fval;
            }
        });
    }

    /** Recurse over structure hierarchy and build structure expression, introducing mvars for each parameter and
        leaf field.

        Example: `create_field_mvars('applicative') =
                    (applicative.mk ?p1 (functor.mk ?p2 ?f1 ?f2...) ?f3..., applicative ?p1)` */
    std::pair<expr, expr> create_field_mvars(name const & nested_S_name) {
        buffer<name> c_names;
        get_constructor_names(m_env, nested_S_name, c_names);
        lean_assert(c_names.size() == 1);
        expr c = m_elab.visit_const_core(copy_pos(m_e, mk_constant(c_names[0])));
        buffer<expr> c_args;
        expr c_type = m_elab.infer_type(c);
        unsigned nparams = m_env.get(nested_S_name).to_inductive_val().get_nparams();

        // iterate over nested_S_name's constructor parameters
        for (unsigned i = 0; is_pi(c_type); i++) {
            name S_fname = deinternalize_field_name(binding_name(c_type));
            expr c_arg;
            expr d = binding_domain(c_type);

            if (i < nparams) {
                /* struct type parameter */
                if (is_explicit(binding_info(c_type)) && !m_expected_type) {
                    m_elab.report_or_throw(elaborator_exception(m_e, sstream()
                            << "invalid structure value {...}, structure parameter '" <<
                            binding_name(c_type)
                            << "' is explicit in the structure constructor '" <<
                            c_names[0] << "' and the expected type is not known"));
                }
                c_arg = m_elab.mk_metavar(d, m_ref);
            } else {
                /* struct field */
                c_arg = m_elab.mk_metavar(S_fname, d, m_ref);

                /* Try to find field value, in the following order:
                 * 1) explicit value from m_fvalues
                 * 2) subobject field: recurse
                 * 3) value from source
                 * 4) opt/auto/implicit param
                 * 6) `..` catchall: placeholder
                 */
                auto it = std::find(m_fnames.begin(), m_fnames.end(), S_fname);
                if (it != m_fnames.end()) {
                    /* explicitly passed field */
                    m_fnames_used.insert(S_fname);
                    expr const & p = m_fvalues[it - m_fnames.begin()];
                    m_field2elab.insert(S_fname, [=](expr const & d) {
                        return m_elab.visit(p, some_expr(consume_auto_opt_param(d)));
                    });
                } else if (auto p = is_subobject_field(m_env, nested_S_name, S_fname)) {
                    /* subobject field */
                    auto num_used = m_fnames_used.size();
                    auto old_missing_fields = m_missing_fields;
                    auto nested = create_field_mvars(*p);
                    if (m_fnames_used.size() == num_used && field_from_source(S_fname)) {
                        // If the subobject doesn't contain any explicitly passed fields, we prefer to use
                        // its value directly from a source so that the two are definitionally equal
                    } else if (!is_explicit(binding_info(c_type)) && m_fnames_used.size() == num_used &&
                            old_missing_fields.size() < m_missing_fields.size()) {
                        // If the subobject is a superclass, doesn't contain any explicitly passed fields,
                        // and has missing fields, we fall back to type inference
                        m_field2elab.insert(S_fname, [=](expr const & d) {
                            return m_elab.mk_instance(d, m_ref);
                        });
                        m_missing_fields = old_missing_fields;
                    } else {
                        // We assign the subtree to the mvar eagerly so that the mvars representing the nested
                        // structure parameters are assigned, which are not inlcuded in the m_mvar2field dependency
                        // tracking
                        lean_always_assert(m_elab.is_def_eq(c_arg, nested.first));
                        // should always hold because `nested.first` is a constructor application
                        lean_always_assert(m_elab.is_mvar_assigned(c_arg));
                    }
                } else if (field_from_source(S_fname)) {
                } else if (has_default_value(m_env, m_S_name, S_fname)) { // note: S_name instead of nested_S_name
                    field_from_default_value(S_fname);
                } else if (is_auto_param(d)) {
                    /* auto param */
                    m_field2elab.insert(S_fname, [=](expr const & d) {
                        if (m_elab.m_in_pattern) {
                            // insert placeholder during pattern elaboration
                            return m_elab.mk_metavar(d, m_ref);
                        } else {
                            auto p = is_auto_param(d);
                            return m_elab.mk_auto_param(p->second, p->first, m_ref);
                        }
                    });
                } else if (!is_explicit(binding_info(c_type))) {
                    /* implicit field */
                    m_field2elab.insert(S_fname, [=](expr const & d) {
                        return is_inst_implicit(binding_info(c_type)) ? m_elab.mk_instance(d, m_ref) : m_elab.mk_metavar(d, m_ref);
                    });
                } else if (m_info.m_catchall) {
                    /* catchall: insert placeholder */
                    m_field2elab.insert(S_fname, [=](expr const & d) {
                        return m_elab.mk_metavar(d, m_ref);
                    });
                } else {
                    /* failure */
                    // Do not log an error immediately because subobjects may need backtracking
                    m_missing_fields.push_back(S_fname);
                    m_field2elab.insert(S_fname, [=](expr const & d) {
                        return m_elab.mk_sorry(some_expr(d), m_ref);
                    });
                }

                m_field2mvar.insert(S_fname, c_arg);
                m_mvar2field.insert(mvar_name(c_arg), S_fname);
            }

            c_args.push_back(c_arg);
            c_type = instantiate(binding_body(c_type), c_arg);
        }
        return mk_pair(mk_app(c, c_args), c_type);
    }

    /** Check `e` for dependencies on fields that have not been inserted yet.
     * Also reduce projections containing mvars, which may remove dependencies.
     * Example: `functor.map (functor.mk ?p1 ?m1 ?m2...) => ?m1`
     */
    void reduce_and_check_deps(expr & e, name const & full_S_fname) {
        if (m_use_subobjects)
            e = reduce_projections_visitor(m_ctx)(e);
        name_set deps;
        e = m_elab.instantiate_mvars(e);
        for_each(e, [&](expr const & e, unsigned) {
            name const *n;
            if (is_metavar(e) && (n = m_mvar2field.find(mvar_name(e))) && !m_ctx.is_assigned(e))
                deps.insert(*n);
            return has_expr_metavar(e);
        });
        if (!deps.empty()) {
            throw field_not_ready_to_synthesize_exception([=]() {
                format error = format("Failed to insert value for '") + format(full_S_fname) +
                               format("', it depends on field(s) '");
                bool first = true;
                deps.for_each([&](name const & dep) {
                    if (!first) error += format("', '");
                    error += format(dep);
                    first = false;
                });
                error += format("', but the value for these fields is not available.") + line() +
                         format("Unfolded type/default value:") + line() +
                         pp_until_meta_visible(m_elab.mk_fmt_ctx(), e) + line() +
                         line();
                return error;
            });
        }
    }

    void elaborate_sources() {
        for (expr src : m_info.m_sources) {
            lean_assert(!m_elab.m_in_pattern);
            src = m_elab.visit(src, none_expr());
            m_elab.synthesize_type_class_instances();
            expr type = m_elab.instantiate_mvars(m_elab.whnf(m_elab.infer_type(src)));
            expr src_S = get_app_fn(type);
            if (!is_constant(src_S) || !is_structure(m_env, const_name(src_S))) {
                auto pp_fn = m_elab.mk_pp_ctx();
                m_elab.report_or_throw(elaborator_exception(m_e,
                                                            format("invalid structure notation source, not a structure") +
                                                            m_elab.pp_indent(pp_fn, src) +
                                                            line() + format("which has type") +
                                                            m_elab.pp_indent(pp_fn, type)));
            } else {
                m_sources.push_back(source {copy_pos(src, mk_as_is(src)), const_name(src_S)});
            }
        }
    }

    void find_structure_name() {
        if (m_expected_type) {
            expr type = m_elab.whnf(*m_expected_type);
            expr S = get_app_fn(type);
            if (!is_constant(S) || !is_structure(m_env, const_name(S))) {
                auto pp_fn = m_elab.mk_pp_ctx();
                throw elaborator_exception(m_e,
                                           format("invalid structure value {...}, expected type is known, "
                                                          "but it is not a structure") +
                                           m_elab.pp_indent(pp_fn, *m_expected_type));
            }
            m_S_name = const_name(S);
        } else if (m_sources.size() == 1 && !m_info.m_catchall) {
            m_S_name = m_sources[0].m_S_name;
        } else {
            throw elaborator_exception(m_e, "invalid structure value {...}, expected type is not known"
                    "(solution: use qualified structure instance { struct_id . ... }");
        }
    }

    /** Repeatedly try to elaborate fields whose dependencies have been elaborated.
      * If we have not made any progress in a round, do a last one collecting any errors. */
    void insert_field_values(expr const & e) {
        bool done = false;
        bool last_progress = true;

        while (!done) {
            done = true;
            bool progress = false;
            format error;
            // Try to resolve helper metavars reachable from e. Note that `m_mvar2field` etc. may contain
            // metavars unreachable from e because of backtracking.
            expr e2 = m_elab.instantiate_mvars(e);
            for_each(e2, [&](expr const & e, unsigned) {
                if (is_metavar(e) && m_mvar2field.contains(mvar_name(e))) {
                    name S_fname = m_mvar2field[mvar_name(e)];
                    name full_S_fname = m_S_name + S_fname;
                    expr expected_type = m_elab.infer_type(e);
                    expr reduced_expected_type = m_elab.instantiate_mvars(expected_type);
                    expr val;

                    try {
                        reduce_and_check_deps(reduced_expected_type, full_S_fname);
                        /* note: we pass the reduced, mvar-free expected type. Otherwise auto params may fail with
                         * "result contains meta-variables". */
                        val = (*m_field2elab.find(S_fname))(reduced_expected_type);
                    } catch (field_not_ready_to_synthesize_exception const & e) {
                        done = false;
                        if (!last_progress)
                            error += e.m_fmt();
                        return true;
                    }

                    expr val_type = m_elab.infer_type(val);
                    if (auto val2 = m_elab.ensure_has_type(val, val_type, expected_type, m_ref)) {
                        /* Make sure mvar is assigned, even if val2 is a meta var as well.
                         * This is important for termination and the `instantiate_mvars` call in `operator()`.
                         * Note that `ensure_has_type` has already unified their types, so this should not result
                         * in any missed unifications.
                         */
                        lean_always_assert(m_ctx.match(e, *val2));
                        trace_elab_detail(tout() << "inserted field '" << S_fname << "' with value '" << *val2 << "'"
                                                 << "\n";)
                        progress = true;
                    } else {
                        format msg = format("type mismatch at field '") + format(S_fname) + format("'");
                        msg += m_elab.pp_type_mismatch(val, val_type, expected_type);
                        throw elaborator_exception(val, msg);
                    }
                }
                return has_metavar(e);
            });
            if (!last_progress && !progress)
                throw elaborator_exception(m_ref, error);
            last_progress = progress;
        }
    }
public:
    visit_structure_instance_fn(elaborator & m_elab, expr const & e, optional<expr> const & expected_type) :
            m_elab(m_elab), m_e(e), m_expected_type(expected_type) {}

    expr operator()() {
        if (!m_S_name.is_anonymous() && !is_structure(m_elab.env(), m_S_name))
            throw elaborator_exception(m_e, sstream() << "invalid structure instance, '" <<
                                                    m_S_name << "' is not the name of a structure type");
        lean_assert(m_fnames.size() == m_fvalues.size());

        elaborate_sources();

        if (m_S_name.is_anonymous())
            find_structure_name();

        if (is_private(m_S_name) && !is_expr_aliased(m_env, m_S_name))
            throw elaborator_exception(m_e, "invalid structure instance, type is a private structure");

        expr e2, c_type;
        std::tie(e2, c_type) = create_field_mvars(m_S_name);

        /* Report missing fields. */
        for (name const & S_fname : m_missing_fields) {
            m_elab.report_or_throw(elaborator_exception(m_e, sstream() << "invalid structure value { ... }, field '"
                                                                       << S_fname << "' was not provided"));
        }

        /* Check if there are alien fields. */
        for (name const & fname : m_fnames) {
            if (!m_fnames_used.contains(fname)) {
                m_elab.report_or_throw(
                        elaborator_exception(m_e, sstream() << "invalid structure value { ... }, '" << fname << "'"
                                                          << " is not a field of structure '" << m_S_name << "'"));
            }
        }

        /* Make sure to unify first to propagate the expected type, we'll report any errors later on. */
        bool type_def_eq = !m_expected_type || m_elab.is_def_eq(*m_expected_type, c_type);

        insert_field_values(e2);

        /* Check expected type */
        if (!type_def_eq) {
            throw elaborator_exception(m_ref, format("type mismatch as structure instance") +
                                            m_elab.pp_type_mismatch(e2, c_type, *m_expected_type));
        }

        if (m_elab.m_in_pattern) {
            /* Instantiate all helper mvars introduced by this function. This is important when elaborating patterns because
             * all mvars left in the final expression are turned into pattern variables by `visit_equation` (see there).
             * For example, the pattern `{a := a}` will result in the input `m_e = {a := ?a}` and result `e2 = foo.mk ?m` with
             * the assignment `?m := ?a` from field elaboration. We want the return value to be `foo.mk ?a` regardless of
             * whether ?a has an assignment (from a dependent pattern) or not. */
            e2 = m_elab.instantiate_mvars(e2, [&](expr const & e) { return m_mvar2field.contains(mvar_name(e)); });
        }
        return e2;
    }
};

expr elaborator::visit_structure_instance(expr const & e, optional<expr> expected_type) {
    synthesize_type_class_instances();
    if (expected_type) {
        expected_type = instantiate_mvars(*expected_type);
        if (is_metavar(*expected_type))
            expected_type = none_expr();
    }
    return visit_structure_instance_fn(*this, e, expected_type)();
}

expr elaborator::visit_mdata(expr const & e, optional<expr> const & expected_type, bool is_app_fn) {
    if (is_as_is(e)) {
        return get_as_is_arg(e);
    } else if (is_choice(e)) {
        return visit_app_core(e, buffer<expr>(), expected_type, e);
    } else if (is_explicit(e) || is_partial_explicit(e)) {
        return visit_app_core(e, buffer<expr>(), expected_type, e);
    } else if (is_anonymous_constructor(e)) {
        if (is_app_fn)
            throw elaborator_exception(e, "invalid constructor ⟨...⟩, function expected");
        return visit_anonymous_constructor(e, expected_type);
    } else if (is_as_atomic(e)) {
        /* ignore annotation */
        expr new_e = visit(get_as_atomic_arg(e), none_expr());
        if (is_app_fn)
            return new_e;
        /* If the as_atomic is not the the function in a function application, then we need to consume
           implicit arguments. */
        return visit_base_app_core(new_e, arg_mask::Default, buffer<expr>(), true, expected_type, e);
    } else if (is_inaccessible(e)) {
        if (is_app_fn)
            throw elaborator_exception(e, "invalid inaccessible term, function expected");
        return visit_inaccessible(e, expected_type);
    } else if (is_frozen_name(e)) {
        return visit(get_annotation_arg(e), expected_type);
    } else if (is_structure_instance(e)) {
        return visit_structure_instance(e, expected_type);
    } else if (is_field_notation(e)) {
        return visit_field(e, expected_type);
    } else if (is_as_pattern(e)) {
        if (!m_in_pattern)
            throw elaborator_exception(e, "invalid occurrence of aliasing pattern, it must only occur in patterns");
        expr new_rhs = visit(get_as_pattern_rhs(e), expected_type);
        expr lhs = get_as_pattern_lhs(e);
        if (!is_def_eq(lhs, new_rhs))
            throw elaborator_exception(e, "cannot unify terms of aliasing pattern");
        return new_rhs;
    } else if (is_equation(e)) {
        throw elaborator_exception(e, "unexpected occurrence of equation");
    } else if (is_equations(e)) {
        lean_assert(!is_app_fn); // visit_convoy is used in this case
        return visit_equations(e);
    } else {
        expr new_e = visit(mdata_expr(e), expected_type);
        return update_mdata(e, new_e);
    }
}

/* If the instance fingerprint has been set, then make sure `type` is not a local instance.
   Then, add a new local declaration to locals. */
expr elaborator::push_local(type_context_old::tmp_locals & locals,
                            name const & n, expr const & type, binder_info binfo, expr const & /* ref */) {
#if 0 // TODO(Leo): the following check is too restrictive
    if (m_ctx.lctx().get_instance_fingerprint() &&
        m_ctx.is_class(type)) {
        throw elaborator_exception(ref, "invalid occurrence of local instance, it must be a declaration parameter");
    }
#endif
    return locals.push_local(n, type, binfo);
}

/* See method above */
expr elaborator::push_let(type_context_old::tmp_locals & locals,
                          name const & n, expr const & type, expr const & value, expr const & /* ref */) {
#if 0 // TODO(Leo): the following check is too restrictive
    if (m_ctx.lctx().get_instance_fingerprint() &&
        m_ctx.is_class(type)) {
        throw elaborator_exception(ref, "invalid occurrence of local instance, it must be a declaration parameter");
    }
#endif
    return locals.push_let(n, type, value);
}

expr elaborator::visit_lambda(expr const & e, optional<expr> const & expected_type) {
    type_context_old::tmp_locals locals(m_ctx);
    expr it  = e;
    expr ex;
    bool has_expected;
    if (expected_type) {
        ex = instantiate_mvars(*expected_type);
        has_expected = true;
    } else {
        has_expected = false;
    }
    while (is_lambda(it)) {
        if (has_expected) {
            ex = try_to_pi(ex);
            if (!is_pi(ex))
                has_expected = false;
        }
        expr d     = instantiate_rev_locals(binding_domain(it), locals);
        expr new_d = visit(d, none_expr());
        if (has_expected) {
            expr ex_d = binding_domain(ex);
            try_is_def_eq(new_d, ex_d);
        }
        expr ref_d = get_ref_for_child(binding_domain(it), it);
        new_d      = ensure_type(new_d, ref_d);
        expr l     = push_local(locals, binding_name(it), new_d, binding_info(it), ref_d);
        it = binding_body(it);
        if (has_expected) {
            lean_assert(is_pi(ex));
            ex = instantiate(binding_body(ex), l);
        }
    }
    expr b = instantiate_rev_locals(it, locals);
    expr new_b;
    if (has_expected) {
        new_b = visit(b, some_expr(ex));
    } else {
        new_b = visit(b, none_expr());
    }
    synthesize();
    expr r = locals.mk_lambda(new_b);
    return r;
}

expr elaborator::visit_pi(expr const & e) {
    type_context_old::tmp_locals locals(m_ctx);
    expr it  = e;
    expr parent_it = e;
    while (is_pi(it)) {
        expr d     = instantiate_rev_locals(binding_domain(it), locals);
        expr new_d = visit(d, none_expr());
        expr ref_d = get_ref_for_child(binding_domain(it), it);
        new_d      = ensure_type(new_d, ref_d);
        expr ref   = binding_domain(it);
        expr l     = push_local(locals, binding_name(it), new_d, binding_info(it), ref);
        parent_it  = it;
        it         = binding_body(it);
    }
    expr b     = instantiate_rev_locals(it, locals);
    expr new_b = visit(b, none_expr());
    expr ref_b = get_ref_for_child(it, parent_it);
    new_b      = ensure_type(new_b, ref_b);
    synthesize();
    expr r = locals.mk_pi(new_b);
    return r;
}

expr elaborator::visit_let(expr const & e, optional<expr> const & expected_type) {
    expr ref = e;
    expr new_type  = visit(let_type(e), none_expr());
    synthesize();
    expr new_value = visit(let_value(e), some_expr(new_type));
    expr ref_value = get_ref_for_child(let_value(e), ref);
    new_value      = enforce_type(new_value, new_type, "invalid let-expression", ref_value);
    synthesize();
    new_type       = instantiate_mvars(new_type);
    new_value      = instantiate_mvars(new_value);
    ensure_no_unassigned_metavars(new_value);
    type_context_old::tmp_locals locals(m_ctx);
    expr l = push_let(locals, let_name(e), new_type, new_value, ref);
    expr body      = instantiate_rev_locals(let_body(e), locals);
    expr new_body  = visit(body, expected_type);
    synthesize();
    expr new_e     = locals.mk_lambda(new_body);
    return new_e;
}

expr elaborator::visit_placeholder(expr const & e, optional<expr> const & expected_type) {
    expr const & ref = e;
    return mk_metavar(expected_type, ref);
}

static bool is_have_expr(expr const & e) {
    return is_app(e) && is_have_annotation(unwrap_pos(app_fn(e)));
}

expr elaborator::strict_visit(expr const & e, optional<expr> const & expected_type) {
    expr r = visit(e, expected_type);
    synthesize();
    r = instantiate_mvars(r);
    ensure_no_unassigned_metavars(r);
    return r;
}

expr elaborator::visit_have_expr(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_have_expr(e));
    expr lambda     = unwrap_pos(get_annotation_arg(app_fn(e)));
    expr type       = binding_domain(lambda);
    expr proof      = app_arg(e);
    expr new_type   = visit(type, none_expr());
    synthesize();
    new_type        = ensure_type(new_type, type);
    expr new_proof  = visit(proof, some_expr(new_type));
    new_proof       = enforce_type(new_proof, new_type, "invalid have-expression", proof);
    synthesize();
    ensure_no_unassigned_metavars(new_proof);
    type_context_old::tmp_locals locals(m_ctx);
    expr ref        = binding_domain(lambda);
    push_local(locals, binding_name(lambda), new_type, binding_info(lambda), ref);
    expr body       = instantiate_rev_locals(binding_body(lambda), locals);
    expr new_body   = visit(body, expected_type);
    expr new_lambda = locals.mk_lambda(new_body);
    return mk_app(mk_have_annotation(new_lambda), new_proof);
}

expr elaborator::visit_suffices_expr(expr const & e, optional<expr> const & expected_type) {
    lean_assert(is_suffices_annotation(e));
    expr body = get_annotation_arg(e);
    if (!is_app(body)) throw elaborator_exception(e, "ill-formed suffices expression");
    expr fn   = unwrap_pos(app_fn(body));
    expr rest = app_arg(body);
    if (!is_lambda(fn)) throw elaborator_exception(e, "ill-formed suffices expression");
    expr new_fn;
    expr type     = binding_domain(fn);
    expr new_type = visit(type, none_expr());
    synthesize();
    {
        type_context_old::tmp_locals locals(m_ctx);
        expr ref        = binding_domain(fn);
        push_local(locals, binding_name(fn), new_type, binding_info(fn), ref);
        expr body       = instantiate_rev_locals(binding_body(fn), locals);
        expr new_body   = visit(body, expected_type);
        synthesize();
        new_fn          = locals.mk_lambda(new_body);
    }
    expr new_rest = visit(rest, some_expr(new_type));
    new_rest      = enforce_type(new_rest, new_type, "invalid suffices-expression", rest);
    return mk_suffices_annotation(mk_app(new_fn, new_rest));
}

static expr mk_emptyc(expr const & src) {
    return copy_pos(src, mk_app(copy_pos(src, mk_constant(get_has_emptyc_emptyc_name())),
                                copy_pos(src, mk_expr_placeholder())));
}

expr elaborator::visit_emptyc_or_emptys(expr const & e, optional<expr> const & expected_type) {
    if (!expected_type) {
        return visit(mk_emptyc(e), expected_type);
    } else {
        synthesize_type_class_instances();
        expr new_expected_type = instantiate_mvars(*expected_type);
        if (is_optional_param(new_expected_type))
            new_expected_type = app_arg(app_fn(new_expected_type));
        expr S = get_app_fn(new_expected_type);
        if (is_constant(S) && is_structure(m_env, const_name(S))) {
            expr empty_struct = copy_pos(e, mk_structure_instance(name(), buffer<name>(), buffer<expr>()));
            return visit(empty_struct, expected_type);
        } else {
            return visit(mk_emptyc(e), expected_type);
        }
    }
}

expr elaborator::visit(expr const & e, optional<expr> const & expected_type) {
    flet<unsigned> inc_depth(m_depth, m_depth+1);
    trace_elab_detail(tout() << "[" << m_depth << "] visiting\n" << e << "\n";
                      if (expected_type) tout() << "expected type:\n" << instantiate_mvars(*expected_type) << "\n";);
    expr e2 = recover_expr_from_exception(expected_type, e, [&] () -> expr {
        if (auto p = get_pos(e)) {
            flet<optional<pos_info>> _(m_last_pos, p);
            return visit(unwrap_pos(e), expected_type);
        } else if (is_placeholder(e)) {
            return visit_placeholder(e, expected_type);
        } else if (is_typed_expr(e)) {
            return visit_typed_expr(e);
        } else if (is_have_expr(e)) {
            return copy_pos(e, visit_have_expr(e, expected_type));
        } else if (is_suffices_annotation(e)) {
            return copy_pos(e, visit_suffices_expr(e, expected_type));
        } else if (is_no_info(e)) {
            flet<bool> set(m_no_info, true);
            return visit(get_annotation_arg(e), expected_type);
        } else if (is_emptyc_or_emptys(e)) {
            return visit_emptyc_or_emptys(e, expected_type);
        } else if (is_sort_wo_universe(e)) {
            return visit(get_annotation_arg(e), expected_type);
        } else {
            switch (e.kind()) {
                case expr_kind::BVar: lean_unreachable();  // LCOV_EXCL_LINE
                case expr_kind::MVar:
                    return e;
                case expr_kind::Lit:
                    switch (lit_value(e).kind()) {
                    case literal_kind::Nat:
                        return visit_prenum(e, expected_type);
                    case literal_kind::String:
                        return e;
                    }
                    lean_unreachable();
                case expr_kind::MData:
                    return visit_mdata(e, expected_type, false);
                case expr_kind::Proj:
                    throw elaborator_exception(e, "unexpected occurrence of proj constructor");
                case expr_kind::Sort:
                    return visit_sort(e);
                case expr_kind::FVar:
                    return visit_local(e, expected_type);
                case expr_kind::Const:
                    return visit_constant(e, expected_type);
                case expr_kind::Lambda:
                    return visit_lambda(e, expected_type);
                case expr_kind::Pi:
                    return visit_pi(e);
                case expr_kind::App:
                    return visit_app(e, expected_type);
                case expr_kind::Let:
                    return visit_let(e, expected_type);
            }
            lean_unreachable(); // LCOV_EXCL_LINE
        }
    });
    return e2;
}

expr elaborator::get_default_numeral_type() {
    // TODO(Leo): allow user to modify default?
    return mk_constant(get_nat_name());
}

void elaborator::synthesize_numeral_types() {
    for (expr const & A : m_numeral_types) {
        trace_elab_numeral(tout() << "synthesize num type: " << A << ", " << instantiate_mvars(A) << "\n";);
        if (is_metavar_app(instantiate_mvars(A))) {
            if (!is_def_eq(A, get_default_numeral_type()))
                report_or_throw(elaborator_exception(A, "invalid numeral, failed to force numeral to be a nat"));
        }
    }
    m_numeral_types = list<expr>();
}

bool elaborator::synthesize_type_class_instance_core(expr const & mvar, expr const & inferred_inst, expr const & inst_type) {
    if (!ready_to_synthesize(inst_type))
        return false;
    metavar_decl mdecl = m_ctx.mctx().get_metavar_decl(mvar);
    expr ref = mvar;
    expr synthesized_inst = mk_instance_core(mdecl.get_context(), inst_type, ref);
    trace_elab_instances(tout() << inferred_inst << " =?= " << synthesized_inst << "\n";);
    if (!m_ctx.is_def_eq_at(mdecl.get_context(), inferred_inst, synthesized_inst)) {
        auto pp_fn = mk_pp_ctx();
        throw elaborator_exception(mvar,
                                   format("synthesized type class instance is not definitionally equal to expression "
                                          "inferred by typing rules, synthesized")
                                   + pp_indent(pp_fn, synthesized_inst)
                                   + line() + format("inferred")
                                   + pp_indent(pp_fn, inferred_inst)).ignore_if(has_synth_sorry(synthesized_inst));
    }
    return true;
}

bool elaborator::try_synthesize_type_class_instance(expr const & mvar) {
    expr inst = instantiate_mvars(mvar);
    expr inst_type = instantiate_mvars(infer_type(inst));
    return synthesize_type_class_instance_core(mvar, inst, inst_type);
}

void elaborator::synthesize_type_class_instances_step() {
    buffer<expr> to_keep;
    buffer<std::tuple<expr, expr, expr>> to_process;
    for (expr const & mvar : m_instances) {
        expr inst      = instantiate_mvars(mvar);
        expr inst_type = instantiate_mvars(infer_type(inst));
        if (!ready_to_synthesize(inst_type)) {
            to_keep.push_back(mvar);
        } else {
            to_process.emplace_back(mvar, inst, inst_type);
        }
    }
    if (to_process.empty())
        return;
    expr mvar, inst, inst_type;
    for (std::tuple<expr, expr, expr> const & curr : to_process) {
        std::tie(mvar, inst, inst_type) = curr;
        synthesize_type_class_instance_core(mvar, inst, inst_type);
    }
    m_instances = to_list(to_keep);
}

void elaborator::synthesize_type_class_instances() {
    while (true) {
        auto old_instances = m_instances;
        synthesize_type_class_instances_step();
        if (is_eqp(old_instances, m_instances))
            return;
    }
}

tactic_state elaborator::mk_tactic_state_for(expr const & mvar) {
    metavar_context mctx = m_ctx.mctx();
    metavar_decl mdecl   = mctx.get_metavar_decl(mvar);
    local_context lctx   = mdecl.get_context().instantiate_mvars(mctx);
    lctx                 = erase_inaccessible_annotations(lctx);
    expr type            = mctx.instantiate_mvars(mdecl.get_type());
    type                 = erase_inaccessible_annotations(type);
    m_ctx.set_mctx(mctx);
    return ::lean::mk_tactic_state_for(m_env, m_opts, m_decl_name, mctx, lctx, type);
}

void elaborator::synthesize() {
    synthesize_numeral_types();
    synthesize_type_class_instances();
}

void elaborator::ensure_no_unassigned_metavars_core(expr & e) {
    e = instantiate_mvars(e);
    if (!has_expr_metavar(e))
        return;
    name_set unassigned;
    for_each(e, [&](expr const & e, unsigned) {
        if (is_metavar_decl_ref(e))
            unassigned.insert(mvar_name(e));
        return true;
    });

    for (auto p : m_user_mvars) {
        auto const & m = p.first;
        auto const & info = p.second;
        auto m2 = get_app_fn(instantiate_mvars(m));
        // `m2` is still `m`, or it looks like a helper mvar introduced by the type_context_old
        if (is_mvar(m2) && unassigned.contains(mvar_name(m2))) {
            tactic_state s = mk_tactic_state_for(m);
            if (m_recover_from_errors) {
                // report error at `m`, but put `sorry` in `m2`
                if (!has_synth_sorry(infer_type(m))) {
                    auto tc = std::make_shared<type_context_old>(m_env, m_opts, m_ctx.mctx(), m_ctx.lctx());
                    message_builder out(tc, m_env, get_global_ios(), get_pos_info_provider()->get_file_name(),
                                        info.m_pos, ERROR);
                    out << "don't know how to synthesize placeholder";
                    if (info.m_context)
                        out << pp_until_meta_visible(mk_fmt_ctx(), *info.m_context);
                    out << "\n";
                    out << "context:\n" << mk_pair(s.pp(), m_opts);
                    out.report();
                    m_has_errors = true;
                }
                m_ctx.assign(m2, mk_sorry(infer_type(m2)));
            } else {
                throw failed_to_synthesize_placeholder_exception(m, s);
            }
        }
    }
    e = instantiate_mvars(e);
}

void elaborator::ensure_no_unassigned_metavars(expr & e) {
    ensure_no_unassigned_metavars_core(e);
    /* If we still have an unassigned mvar, it means the mvar doesn't directly correspond to a user-facing mvar.
     * That's bad (because we can't generate a sensible error message) and shouldn't happen. */
    lean_assert(has_synth_sorry(e) || !has_expr_metavar(e));
}

elaborator::snapshot::snapshot(elaborator const & e) {
    m_saved_mctx               = e.m_ctx.mctx();
    m_saved_instances          = e.m_instances;
    m_saved_numeral_types      = e.m_numeral_types;
}

void elaborator::snapshot::restore(elaborator & e) {
    e.m_ctx.set_mctx(m_saved_mctx);
    e.m_instances          = m_saved_instances;
    e.m_numeral_types      = m_saved_numeral_types;
}

/**
    \brief Auxiliary class for creating nice names for universe
    parameters introduced by the elaborator.

    This class also transforms remaining universe metavariables
    into parameters */
struct sanitize_param_names_fn : public replace_visitor {
    type_context_old &  m_ctx;
    name            m_p{"u"};
    name_set        m_L; /* All parameter names in the input expression. */
    unsigned        m_idx{1};
    buffer<name> &  m_new_param_names;
    /* If m_fixed == true, then we do not introduce new parameters.
       Remark: we should be able to infer the set of universe variables using just the
       theorem type. */
    bool            m_fixed;

    sanitize_param_names_fn(type_context_old & ctx, buffer<name> & new_lp_names):
        m_ctx(ctx), m_new_param_names(new_lp_names), m_fixed(false) {}

    sanitize_param_names_fn(type_context_old & ctx, elaborator::theorem_finalization_info const & info,
                            buffer<name> & new_lp_names):
        m_ctx(ctx), m_L(info.m_L),
        m_new_param_names(new_lp_names), m_fixed(true) {}

    level mk_param() {
        while (true) {
            name new_n = m_p.append_after(m_idx);
            m_idx++;
            if (!m_L.contains(new_n)) {
                m_new_param_names.push_back(new_n);
                return mk_univ_param(new_n);
            }
        }
    }

    level sanitize(level const & l) {
        name p("u");
        return replace(l, [&](level const & l) -> optional<level> {
                if (is_mvar(l)) {
                    if (is_metavar_decl_ref(l) && m_ctx.is_assigned(l)) {
                        return some_level(sanitize(*m_ctx.get_assignment(l)));
                    } else {
                        auto p = m_fixed ? mk_level_zero() : mk_param();
                        m_ctx.assign(l, p);
                        return some_level(p);
                    }
                }
                return none_level();
            });
    }

    virtual expr visit_constant(expr const & e) override {
        return update_constant(e, map(const_levels(e), [&](level const & l) { return sanitize(l); }));
    }

    virtual expr visit_sort(expr const & e) override {
        return update_sort(e, sanitize(sort_level(e)));
    }

    void collect_params(expr const & e) {
        m_L = collect_univ_params(e, m_L);
    }

    void collect_local_context_params() {
        m_ctx.lctx().for_each([&](local_decl const & l) {
                collect_params(m_ctx.instantiate_mvars(l.get_type()));
                if (auto v = l.get_value())
                    collect_params(m_ctx.instantiate_mvars(*v));
            });
    }

    expr sanitize(expr const & e) {
        expr r = operator()(e);
        return r;
    }

    elaborator::theorem_finalization_info mk_info() {
        return {m_L};
    }
};

/** When the output of the elaborator may contain meta-variables, we convert the type_context_old level meta-variables
    into regular kernel meta-variables. */
static expr replace_with_simple_metavars(metavar_context mctx, name_map<expr> & cache, expr const & e) {
    if (!has_expr_metavar(e)) return e;
    return replace(e, [&](expr const & e, unsigned) {
            if (is_metavar(e)) {
                if (auto r = cache.find(mvar_name(e))) {
                    return some_expr(*r);
                } else if (auto decl = mctx.find_metavar_decl(e)) {
                    expr new_type = replace_with_simple_metavars(mctx, cache, mctx.instantiate_mvars(decl->get_type()));
                    expr new_mvar = mk_metavar(mvar_name(e), new_type);
                    cache.insert(mvar_name(e), new_mvar);
                    return some_expr(new_mvar);
                } else if (is_metavar_decl_ref(e)) {
                    throw exception("unexpected occurrence of internal elaboration metavariable");
                } else {
                    return none_expr();
                }
            } else {
                return none_expr();
            }
        });
}

expr elaborator::elaborate(expr const & e) {
    expr r = visit(e,  none_expr());
    trace_elab_detail(tout() << "result before final checkpoint\n" << r << "\n";);
    synthesize();
    return r;
}

expr elaborator::elaborate_type(expr const & e) {
    expr const & ref = e;
    expr new_e = ensure_type(visit(e, none_expr()), ref);
    synthesize();
    return new_e;
}

expr_pair elaborator::elaborate_with_type(expr const & e, expr const & e_type) {
    expr const & ref = e;
    expr new_e, new_e_type;
    {
        expr Type  = visit(copy_pos(e_type, mk_sort(mk_level_placeholder())), none_expr());
        new_e_type = visit(e_type, some_expr(Type));
        new_e_type = ensure_type(new_e_type, e_type);
        new_e      = visit(e,      some_expr(new_e_type));
        synthesize();
    }
    new_e = enforce_type(new_e, new_e_type, "type mismatch", ref);
    return mk_pair(new_e, new_e_type);
}

void elaborator::finalize_core(sanitize_param_names_fn & S, buffer<expr> & es,
                               bool check_unassigned, bool to_simple_metavar, bool collect_local_ctx) {
    name_map<expr> to_simple_mvar_cache;
    for (expr & e : es) {
        e = instantiate_mvars(e);
        if (check_unassigned)
            ensure_no_unassigned_metavars(e);
        if (!check_unassigned && to_simple_metavar) {
            e = replace_with_simple_metavars(m_ctx.mctx(), to_simple_mvar_cache, e);
        }
        e = instantiate_mvars(e);
        S.collect_params(e);
    }
    if (collect_local_ctx)
        S.collect_local_context_params();
    for (expr & e : es) {
        e = S.sanitize(e);
    }
}

void elaborator::finalize(buffer<expr> & es, buffer<name> & new_lp_names, bool check_unassigned, bool to_simple_metavar) {
    sanitize_param_names_fn S(m_ctx, new_lp_names);
    finalize_core(S, es, check_unassigned, to_simple_metavar, true);
}

pair<expr, names> elaborator::finalize(expr const & e, bool check_unassigned, bool to_simple_metavar) {
    buffer<expr> es; es.push_back(e);
    buffer<name> new_lp_names;
    finalize(es, new_lp_names, check_unassigned, to_simple_metavar);
    return mk_pair(es[0], names(new_lp_names));
}

auto elaborator::finalize_theorem_type(expr const & type, buffer<name> & new_lp_names)
    -> pair<expr, theorem_finalization_info> {
    sanitize_param_names_fn S(m_ctx, new_lp_names);
    buffer<expr> es; es.push_back(type);
    bool check_unassigned  = true;
    bool to_simple_metavar = false;
    bool collect_local_ctx = true;
    finalize_core(S, es, check_unassigned, to_simple_metavar, collect_local_ctx);
    return mk_pair(es[0], S.mk_info());
}

expr elaborator::finalize_theorem_proof(expr const & val, theorem_finalization_info const & info) {
    buffer<name> dummy;
    sanitize_param_names_fn S(m_ctx, info, dummy);
    buffer<expr> es; es.push_back(val);
    bool check_unassigned  = true;
    bool to_simple_metavar = false;
    bool collect_local_ctx = false;
    finalize_core(S, es, check_unassigned, to_simple_metavar, collect_local_ctx);
    return es[0];
}

pair<expr, names>
elaborate(environment & env, options const & opts, name const & decl_name,
          metavar_context & mctx, local_context const & lctx, expr const & e,
          bool check_unassigned, bool recover_from_errors) {
    elaborator elab(env, opts, decl_name, mctx, lctx, recover_from_errors);
    expr r = elab.elaborate(e);
    auto p = elab.finalize(r, check_unassigned, true);
    mctx = elab.mctx();
    env  = elab.env();
    return p;
}

void initialize_elaborator() {
    g_elab_strategy = new name("elab_strategy");
    register_trace_class("elaborator");
    register_trace_class(name({"elaborator", "numeral"}));
    register_trace_class(name({"elaborator", "instances"}));
    register_trace_class(name({"elaborator", "equation"}));
    register_trace_class("elaborator_detail");
    register_trace_class("elaborator_debug");

    char const * elab_simple             = "elabSimple";
    char const * elab_with_expected_type = "elabWithExpectedType";
    char const * elab_as_eliminator      = "elabAsEliminator";

    register_system_attribute(
        elaborator_strategy_attribute(
            *g_elab_strategy,
            "internal attribute for the elaborator strategy for a given constant"));

    register_system_attribute(
        elaborator_strategy_proxy_attribute(
            elab_with_expected_type,
            "instructs elaborator that the arguments of the function application (f ...) "
            "should be elaborated using information about the expected type",
            elaborator_strategy::WithExpectedType));

    register_system_attribute(
        elaborator_strategy_proxy_attribute(
            elab_as_eliminator,
            "instructs elaborator that the arguments of the function application (f ...) "
            "should be elaborated as f were an eliminator",
            elaborator_strategy::AsEliminator));

    register_system_attribute(
        elaborator_strategy_proxy_attribute(
            elab_simple,
            "instructs elaborator that the arguments of the function application (f ...) "
            "should be elaborated from left to right, and without propagating information from the expected type "
            "to its arguments",
            elaborator_strategy::Simple));

    register_incompatible(elab_simple, elab_with_expected_type);
    register_incompatible(elab_simple, elab_as_eliminator);
    register_incompatible(elab_with_expected_type, elab_as_eliminator);

    g_elaborator_coercions          = new name{"elaborator", "coercions"};
    register_bool_option(*g_elaborator_coercions, LEAN_DEFAULT_ELABORATOR_COERCIONS,
                         "(elaborator) if true, the elaborator will automatically introduce coercions");
}

void finalize_elaborator() {
    delete g_elab_strategy;
    delete g_elaborator_coercions;
}
}