lean2/src/frontends/lean/frontend_elaborator.cpp
Leonardo de Moura 9eb4dc4a81 feat(kernel, library/elaborator, frontends/lean): improve how elaborator_exceptions are displayed in the Lean frontend
This commit affects different modules.
I used the following approach:
1- I store the metavariable environment at unification_failure_justifications. The idea is to capture the set of instantiated metavariables at the time of failure.
2- I added a remove_detail function. It removes propagation steps from the justification tree object. I also remove the backtracking search space associated with higher-order unificiation. I keep only the search related to case-splits due to coercions and overloads.

3- I use the metavariable environment captured at step 1 when pretty printing the justification of an elaborator_exception.

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
2014-01-03 17:18:23 -08:00

522 lines
21 KiB
C++

/*
Copyright (c) 2013 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: Leonardo de Moura
*/
#include <vector>
#include <utility>
#include <algorithm>
#include <limits>
#include "util/interrupt.h"
#include "util/freset.h"
#include "kernel/type_checker.h"
#include "kernel/type_checker_justification.h"
#include "kernel/normalizer.h"
#include "kernel/replace_visitor.h"
#include "kernel/unification_constraint.h"
#include "kernel/instantiate.h"
#include "kernel/builtin.h"
#include "library/io_state_stream.h"
#include "library/placeholder.h"
#include "library/elaborator/elaborator.h"
#include "frontends/lean/frontend.h"
#include "frontends/lean/frontend_elaborator.h"
namespace lean {
static name g_x_name("x");
static format g_assignment_fmt = format(":=");
static format g_unification_u_fmt = format("\u2248");
static format g_unification_fmt = format("=?=");
/**
\brief Internal value used to store choices for the elaborator.
This is a transient value that is only used to setup a problem
for the elaborator.
*/
struct choice_value : public value {
std::vector<expr> m_choices;
choice_value(unsigned num_fs, expr const * fs):m_choices(fs, fs + num_fs) {}
virtual ~choice_value() {}
virtual expr get_type() const { lean_unreachable(); } // LCOV_EXCL_LINE
virtual void write(serializer & ) const { lean_unreachable(); } // LCOV_EXCL_LINE
virtual name get_name() const { return name("Choice"); }
virtual void display(std::ostream & out) const {
out << "(Choice";
for (auto c : m_choices) {
out << " (" << c << ")";
}
out << ")";
}
// Remark: we don't implement the pp methods because the lean::pp_fn formatter
// object has support for formatting choice internal values.
};
expr mk_choice(unsigned num_fs, expr const * fs) {
lean_assert(num_fs >= 2);
return mk_value(*(new choice_value(num_fs, fs)));
}
bool is_choice(expr const & e) {
return is_value(e) && dynamic_cast<choice_value const *>(&to_value(e)) != nullptr;
}
choice_value const & to_choice_value(expr const & e) {
lean_assert(is_choice(e));
return static_cast<choice_value const &>(to_value(e));
}
unsigned get_num_choices(expr const & e) {
return to_choice_value(e).m_choices.size();
}
expr const & get_choice(expr const & e, unsigned i) {
return to_choice_value(e).m_choices[i];
}
class coercion_justification_cell : public justification_cell {
context m_ctx;
expr m_src;
public:
coercion_justification_cell(context const & c, expr const & src):m_ctx(c), m_src(src) {}
virtual ~coercion_justification_cell() {}
virtual format pp_header(formatter const & fmt, options const & opts, optional<metavar_env> const & menv) const {
unsigned indent = get_pp_indent(opts);
format expr_fmt = fmt(m_ctx, instantiate_metavars(menv, m_src), false, opts);
format r;
r += format("Coercion for");
r += nest(indent, compose(line(), expr_fmt));
return r;
}
virtual void get_children(buffer<justification_cell*> &) const {}
virtual optional<expr> get_main_expr() const { return some_expr(m_src); }
context const & get_context() const { return m_ctx; }
};
class overload_justification_cell : public justification_cell {
context m_ctx;
expr m_app;
public:
overload_justification_cell(context const & c, expr const & app):m_ctx(c), m_app(app) {}
virtual ~overload_justification_cell() {}
virtual format pp_header(formatter const & fmt, options const & opts, optional<metavar_env> const & menv) const {
unsigned indent = get_pp_indent(opts);
format expr_fmt = fmt(m_ctx, instantiate_metavars(menv, m_app), false, opts);
format r;
r += format("Overloading at");
r += nest(indent, compose(line(), expr_fmt));
return r;
}
virtual void get_children(buffer<justification_cell*> &) const {}
virtual optional<expr> get_main_expr() const { return some_expr(m_app); }
context const & get_context() const { return m_ctx; }
expr const & get_app() const { return m_app; }
};
inline justification mk_coercion_justification(context const & ctx, expr const & e) {
return justification(new coercion_justification_cell(ctx, e));
}
inline justification mk_overload_justification(context const & ctx, expr const & app) {
return justification(new overload_justification_cell(ctx, app));
}
/**
\brief Actual implementation of the frontend_elaborator.
*/
class frontend_elaborator::imp {
environment m_env;
type_checker m_type_checker;
normalizer m_normalizer;
metavar_env m_menv;
buffer<unification_constraint> m_ucs;
// The following mapping is used to store the relationship
// between elaborated expressions and non-elaborated expressions.
// We need that because a frontend may associate line number information
// with the original non-elaborated expressions.
expr_map<expr> m_trace;
/**
\brief Replace placeholders and choices with metavariables.
It also introduce metavariables where coercions are needed.
*/
struct preprocessor : public replace_visitor {
imp & m_ref;
preprocessor(imp & r):m_ref(r) {}
expr instantiate(expr const & e, expr const & v) {
return ::lean::instantiate(e, v, m_ref.m_menv);
}
environment const & env() const { return m_ref.m_env; }
virtual expr visit_constant(expr const & e, context const & ctx) {
if (is_placeholder(e)) {
expr m = m_ref.m_menv->mk_metavar(ctx, visit(const_type(e), ctx));
m_ref.m_trace[m] = e;
return m;
} else {
return e;
}
}
/**
\brief Return the type of \c e if possible.
The idea is to use the type to catch the easy cases where we can solve
overloads (aka choices) and coercions during preprocessing.
*/
optional<expr> get_type(expr const & e, context const & ctx) {
try {
return some_expr(m_ref.m_type_checker.infer_type(e, ctx));
} catch (exception &) {
return none_expr();
}
}
bool is_convertible(expr const & from, expr const & to) {
try {
return m_ref.m_type_checker.is_convertible(from, to);
} catch (exception &) {
return false;
}
}
/**
\brief Make sure f_t is a Pi, if it is not, then return none_expr()
*/
optional<expr> check_pi(optional<expr> const & f_t, context const & ctx) {
if (!f_t || is_pi(*f_t)) {
return f_t;
} else {
expr r = m_ref.m_normalizer(*f_t, ctx, m_ref.m_menv);
if (is_pi(r))
return some_expr(r);
else
return none_expr();
}
}
expr add_coercion_mvar_app(list<expr_pair> const & l, expr const & a, expr const & a_t,
context const & ctx, expr const & original_a) {
buffer<expr> choices;
expr mvar = m_ref.m_menv->mk_metavar(ctx);
for (auto p : l) {
choices.push_back(p.second);
}
choices.push_back(mk_lambda(g_x_name, a_t, mk_var(0))); // add indentity function
std::reverse(choices.begin(), choices.end());
m_ref.m_ucs.push_back(mk_choice_constraint(ctx, mvar, choices.size(), choices.data(),
mk_coercion_justification(ctx, original_a)));
return mk_app(mvar, a);
}
optional<expr> find_coercion(list<expr_pair> const & l, expr const & to_type) {
for (auto p : l) {
if (p.first == to_type) {
return some_expr(p.second);
}
}
return none_expr();
}
/**
\brief Try to solve overload at preprocessing time.
*/
void choose(buffer<expr> & f_choices, buffer<optional<expr>> & f_choice_types,
buffer<expr> const & args, buffer<optional<expr>> const & arg_types,
context const & ctx) {
unsigned best_num_coercions = std::numeric_limits<unsigned>::max();
unsigned num_choices = f_choices.size();
unsigned num_args = args.size();
buffer<unsigned> delayed;
buffer<unsigned> matched;
for (unsigned j = 0; j < num_choices; j++) {
optional<expr> f_t = f_choice_types[j];
unsigned num_coercions = 0; // number of coercions needed by current choice
unsigned num_skipped_args = 0;
unsigned i = 1;
for (; i < num_args; i++) {
f_t = check_pi(f_t, ctx);
if (!f_t) {
// can't process this choice at preprocessing time
delayed.push_back(j);
break;
} else {
expr expected = abst_domain(*f_t);
optional<expr> given = arg_types[i];
if (!given) {
num_skipped_args++;
} else {
if (!has_metavar(expected) && !has_metavar(*given)) {
if (m_ref.m_type_checker.is_convertible(*given, expected, ctx)) {
// compatible
} else if (get_coercion(env(), *given, expected)) {
// compatible if using coercion
num_coercions++;
} else {
// failed, this choice does not work
break;
}
} else {
num_skipped_args++;
}
}
f_t = some_expr(instantiate(abst_body(*f_t), args[i]));
}
}
if (i == num_args) {
if (num_skipped_args > 0) {
// should keep this choice because we could not check all arguments
delayed.push_back(j);
} else if (num_coercions < best_num_coercions) {
// found best choice
best_num_coercions = num_coercions;
matched.clear();
matched.push_back(j);
} else {
matched.push_back(j);
}
}
}
matched.append(delayed);
if (matched.size() == 0) {
// TODO(Leo): must use another exception that stores the choices considered.
// We currently do nothing, and let the elaborator to sign the error
} else {
buffer<expr> to_keep;
buffer<optional<expr>> to_keep_types;
std::sort(matched.begin(), matched.end()); // we must preserve the original order
for (unsigned i : matched) {
to_keep.push_back(f_choices[i]);
to_keep_types.push_back(f_choice_types[i]);
}
f_choices.clear();
f_choice_types.clear();
f_choices.append(to_keep);
f_choice_types.append(to_keep_types);
}
}
/**
\brief Create a metavariable for representing the choice.
*/
expr mk_overload_mvar(buffer<expr> & f_choices, context const & ctx, expr const & src) {
std::reverse(f_choices.begin(), f_choices.end());
expr mvar = m_ref.m_menv->mk_metavar(ctx);
m_ref.m_ucs.push_back(mk_choice_constraint(ctx, mvar, f_choices.size(), f_choices.data(),
mk_overload_justification(ctx, src)));
return mvar;
}
virtual expr visit_app(expr const & e, context const & ctx) {
expr f = arg(e, 0);
optional<expr> f_t;
buffer<expr> args;
buffer<optional<expr>> arg_types;
args.push_back(expr()); // placeholder
arg_types.push_back(none_expr()); // placeholder
for (unsigned i = 1; i < num_args(e); i++) {
expr a = arg(e, i);
expr new_a = visit(a, ctx);
optional<expr> new_a_t = get_type(new_a, ctx);
args.push_back(new_a);
arg_types.push_back(new_a_t);
}
if (is_choice(f)) {
buffer<expr> f_choices;
buffer<optional<expr>> f_choice_types;
unsigned num_alts = get_num_choices(f);
for (unsigned i = 0; i < num_alts; i++) {
expr c = get_choice(f, i);
expr new_c = visit(c, ctx);
optional<expr> new_c_t = get_type(new_c, ctx);
f_choices.push_back(new_c);
f_choice_types.push_back(new_c_t);
}
choose(f_choices, f_choice_types, args, arg_types, ctx);
if (f_choices.size() > 1) {
args[0] = mk_overload_mvar(f_choices, ctx, e);
for (unsigned i = 1; i < args.size(); i++) {
if (arg_types[i]) {
list<expr_pair> coercions = get_coercions(env(), *(arg_types[i]));
if (coercions)
args[i] = add_coercion_mvar_app(coercions, args[i], *(arg_types[i]), ctx, arg(e, i));
}
}
return mk_app(args);
} else {
// managed to solve overload at preprocessing time
f = f_choices[0];
f_t = f_choice_types[0];
}
} else {
f = visit(f, ctx);
f_t = get_type(f, ctx);
}
buffer<expr> new_args;
new_args.push_back(f);
for (unsigned i = 1; i < num_args(e); i++) {
f_t = check_pi(f_t, ctx);
expr a = arg(e, i);
expr new_a = args[i];
optional<expr> new_a_t = arg_types[i];
if (new_a_t) {
list<expr_pair> coercions = get_coercions(env(), *new_a_t);
if (coercions) {
if (!f_t) {
new_a = add_coercion_mvar_app(coercions, new_a, *new_a_t, ctx, a);
} else {
expr expected = abst_domain(*f_t);
if (!is_convertible(*new_a_t, expected)) {
optional<expr> c = find_coercion(coercions, expected);
if (c) {
new_a = mk_app(*c, new_a); // apply coercion
} else {
new_a = add_coercion_mvar_app(coercions, new_a, *new_a_t, ctx, a);
}
}
}
}
}
new_args.push_back(new_a);
if (f_t)
f_t = some_expr(instantiate(abst_body(*f_t), new_a));
}
return mk_app(new_args);
}
virtual expr visit_let(expr const & e, context const & ctx) {
lean_assert(is_let(e));
return update_let(e, [&](optional<expr> const & t, expr const & v, expr const & b) {
optional<expr> new_t = visit(t, ctx);
expr new_v = visit(v, ctx);
if (new_t) {
optional<expr> new_v_t = get_type(new_v, ctx);
if (new_v_t && *new_t != *new_v_t) {
list<expr_pair> coercions = get_coercions(env(), *new_v_t);
if (coercions) {
new_v = add_coercion_mvar_app(coercions, new_v, *new_v_t, ctx, v);
}
}
}
{
freset<cache> reset(m_cache);
expr new_b = visit(b, extend(ctx, let_name(e), new_t, new_v));
return std::make_tuple(new_t, new_v, new_b);
}
});
}
optional<expr> visit(optional<expr> const & e, context const & ctx) {
return replace_visitor::visit(e, ctx);
}
virtual expr visit(expr const & e, context const & ctx) {
check_interrupted();
expr r = replace_visitor::visit(e, ctx);
if (!is_eqp(r, e))
m_ref.m_trace[r] = e;
return r;
}
};
metavar_env elaborate_core() {
// std::stable_sort(m_ucs.begin(), m_ucs.end(),
// [](unification_constraint const & c1, unification_constraint const & c2) {
// return !is_choice(c1) && is_choice(c2);
// });
elaborator elb(m_env, m_menv, m_ucs.size(), m_ucs.data());
return elb.next();
}
public:
imp(environment const & env):
m_env(env),
m_type_checker(m_env),
m_normalizer(m_env) {
}
std::pair<expr, metavar_env> elaborate(expr const & e) {
// std::cout << "Elaborate " << e << "\n";
clear();
expr new_e = preprocessor(*this)(e);
// std::cout << "After preprocessing\n" << new_e << "\n";
if (has_metavar(new_e)) {
m_type_checker.check(new_e, context(), m_menv, m_ucs);
// for (auto c : m_ucs) {
// formatter fmt = mk_simple_formatter();
// std::cout << c.pp(fmt, options(), nullptr, false) << "\n";
// }
metavar_env new_menv = elaborate_core();
return mk_pair(new_menv->instantiate_metavars(new_e), new_menv);
} else {
return mk_pair(new_e, metavar_env());
}
}
std::tuple<expr, expr, metavar_env> elaborate(name const & n, expr const & t, expr const & e) {
// std::cout << "Elaborate " << t << " : " << e << "\n";
clear();
expr new_t = preprocessor(*this)(t);
expr new_e = preprocessor(*this)(e);
// std::cout << "After preprocessing\n" << new_t << "\n" << new_e << "\n";
if (has_metavar(new_e) || has_metavar(new_t)) {
m_type_checker.check(new_t, context(), m_menv, m_ucs);
expr new_e_t = m_type_checker.check(new_e, context(), m_menv, m_ucs);
m_ucs.push_back(mk_convertible_constraint(context(), new_e_t, new_t,
mk_def_type_match_justification(context(), n, e)));
// for (auto c : m_ucs) {
// formatter fmt = mk_simple_formatter();
// std::cout << c.pp(fmt, options(), nullptr, false) << "\n";
// }
metavar_env new_menv = elaborate_core();
return std::make_tuple(new_menv->instantiate_metavars(new_t),
new_menv->instantiate_metavars(new_e),
new_menv);
} else {
return std::make_tuple(new_t, new_e, metavar_env());
}
}
expr const & get_original(expr const & e) {
expr const * r = &e;
while (true) {
auto it = m_trace.find(*r);
if (it == m_trace.end()) {
return *r;
} else {
r = &(it->second);
}
}
}
void clear() {
m_menv = metavar_env();
m_ucs.clear();
m_trace.clear();
m_type_checker.clear();
m_normalizer.clear();
}
environment const & get_environment() const {
return m_env;
}
};
frontend_elaborator::frontend_elaborator(environment const & env):m_ptr(std::make_shared<imp>(env)) {}
frontend_elaborator::~frontend_elaborator() {}
std::pair<expr, metavar_env> frontend_elaborator::operator()(expr const & e) { return m_ptr->elaborate(e); }
std::tuple<expr, expr, metavar_env> frontend_elaborator::operator()(name const & n, expr const & t, expr const & e) {
return m_ptr->elaborate(n, t, e);
}
expr const & frontend_elaborator::get_original(expr const & e) const { return m_ptr->get_original(e); }
void frontend_elaborator::clear() { m_ptr->clear(); }
void frontend_elaborator::reset(environment const & env) { m_ptr.reset(new imp(env)); }
environment const & frontend_elaborator::get_environment() const { return m_ptr->get_environment(); }
}