michael/lean2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(frontends/lean): add kind and type to index, closes #89

Browse source 
Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>
This commit is contained in:
Leonardo de Moura 2014-08-23 12:39:59 -07:00
parent 01736bf82a
commit b13851ba13
7 changed files with 63 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

17
src/frontends/lean/decl_cmds.cpp
View file

@ -71,6 +71,9 @@ void update_univ_parameters(buffer<name> & ls_buffer, name_set const & found, pa
});
}
static name g_axiom("axiom");
static name g_variable("variable");
static environment declare_var(parser & p, environment env,
name const & n, level_param_names const & ls, expr const & type,
bool is_axiom, optional<binder_info> const & _bi, pos_info const & pos) {
@ -82,11 +85,13 @@ static environment declare_var(parser & p, environment env,
} else {
name const & ns = get_namespace(env);
name full_n = ns + n;
p.add_decl_index(full_n, pos);
if (is_axiom)
if (is_axiom) {
env = module::add(env, check(env, mk_axiom(full_n, ls, type)));
else
p.add_decl_index(full_n, pos, g_axiom, type);
} else {
env = module::add(env, check(env, mk_var_decl(full_n, ls, type)));
p.add_decl_index(full_n, pos, g_variable, type);
}
if (!ns.is_anonymous())
env = add_expr_alias(env, n, full_n);
return env;
@ -269,8 +274,6 @@ environment definition_cmd_core(parser & p, bool is_theorem, bool _is_opaque) {
real_n = ns + n;
}
p.add_decl_index(real_n, n_pos);
if (in_section(env)) {
buffer<expr> section_ps;
collect_section_locals(type, value, p, section_ps);
@ -297,6 +300,8 @@ environment definition_cmd_core(parser & p, bool is_theorem, bool _is_opaque) {
cd = check(env, mk_theorem(real_n, c_ls, c_type, c_value));
else
cd = check(env, mk_definition(env, real_n, c_ls, c_type, c_value, modifiers.m_is_opaque));
if (!modifiers.m_is_private)
p.add_decl_index(real_n, n_pos, p.get_cmd_token(), c_type);
env = module::add(env, *cd);
found_cached = true;
} catch (exception&) {}
@ -322,6 +327,8 @@ environment definition_cmd_core(parser & p, bool is_theorem, bool _is_opaque) {
env = module::add(env, check(env, mk_definition(env, real_n, new_ls, type, value, modifiers.m_is_opaque)));
p.cache_definition(real_n, pre_type, pre_value, new_ls, type, value);
}
if (!modifiers.m_is_private)
p.add_decl_index(real_n, n_pos, p.get_cmd_token(), type);
}
if (real_n != n)

25
src/frontends/lean/inductive_cmd.cpp
View file

@ -53,6 +53,10 @@ intro_rule update_intro_rule(intro_rule const & r, expr const & t) {
static name g_tmp_prefix = name::mk_internal_unique_name();
static name g_inductive("inductive");
static name g_intro("intro");
static name g_recursor("recursor");
struct inductive_cmd_fn {
typedef std::unique_ptr<type_checker> type_checker_ptr;
parser & m_p;
@ -68,6 +72,8 @@ struct inductive_cmd_fn {
level m_u; // temporary auxiliary global universe used for inferring the result universe of an inductive datatype declaration.
bool m_infer_result_universe;
name_set m_relaxed_implicit_infer; // set of introduction rules where we do not use strict implicit parameter infererence
typedef std::tuple<name, name, pos_info> decl_info;
buffer<decl_info> m_decl_info; // auxiliary buffer used to populate declaration_index
inductive_cmd_fn(parser & p):m_p(p) {
m_env = p.env();
@ -97,9 +103,12 @@ struct inductive_cmd_fn {
name id = m_p.check_id_next("invalid declaration, identifier expected");
check_atomic(id);
name full_id = m_namespace + id;
m_p.add_decl_index(full_id, m_pos);
if (!is_intro)
m_p.add_decl_index(mk_rec_name(full_id), m_pos);
if (is_intro) {
m_decl_info.emplace_back(full_id, g_intro, m_pos);
} else {
m_decl_info.emplace_back(full_id, g_inductive, m_pos);
m_decl_info.emplace_back(mk_rec_name(full_id), g_recursor, m_pos);
}
return full_id;
}
@ -547,6 +556,15 @@ struct inductive_cmd_fn {
out << "\n";
}
void update_declaration_index(environment const & env) {
name n, k; pos_info p;
for (auto const & info : m_decl_info) {
std::tie(n, k, p) = info;
expr type = env.get(n).get_type();
m_p.add_decl_index(n, p, k, type);
}
}
environment operator()() {
parser::no_undef_id_error_scope err_scope(m_p);
buffer<inductive_decl> decls;
@ -566,6 +584,7 @@ struct inductive_cmd_fn {
}
level_param_names ls = to_list(m_levels.begin(), m_levels.end());
environment env = module::add_inductive(m_p.env(), ls, m_num_params, to_list(decls.begin(), decls.end()));
update_declaration_index(env);
return add_aliases(env, ls, section_params, decls);
}
};

5
src/frontends/lean/parser.cpp
View file

@ -121,9 +121,9 @@ optional<std::tuple<level_param_names, expr, expr>> parser::find_cached_definiti
return optional<std::tuple<level_param_names, expr, expr>>();
}
void parser::add_decl_index(name const & n, pos_info const & pos) {
void parser::add_decl_index(name const & n, pos_info const & pos, name const & k, expr const & t) {
if (m_index)
m_index->add_decl(get_stream_name(), pos, n);
m_index->add_decl(get_stream_name(), pos, n, k, t);
}
void parser::add_ref_index(name const & n, pos_info const & pos) {
@ -1105,6 +1105,7 @@ void parser::parse_command() {
lean_assert(curr() == scanner::token_kind::CommandKeyword);
m_last_cmd_pos = pos();
name const & cmd_name = get_token_info().value();
m_cmd_token = get_token_info().token();
if (auto it = cmds().find(cmd_name)) {
next();
m_env = it->get_fn()(*this);

6
src/frontends/lean/parser.h
View file

@ -98,6 +98,9 @@ class parser {
// index support
declaration_index * m_index;
// curr command token
name m_cmd_token;
void display_warning_pos(unsigned line, unsigned pos);
void display_warning_pos(pos_info p);
void display_error_pos(unsigned line, unsigned pos);
@ -191,7 +194,7 @@ public:
bool collecting_info() const { return m_info_manager; }
void set_index(declaration_index * i) { m_index = i; }
void add_decl_index(name const & n, pos_info const & pos);
void add_decl_index(name const & n, pos_info const & pos, name const & k, expr const & t);
void add_ref_index(name const & n, pos_info const & pos);
environment const & env() const { return m_env; }
@ -215,6 +218,7 @@ public:
pos_info pos_of(expr const & e, pos_info default_pos);
pos_info pos_of(expr const & e) { return pos_of(e, pos()); }
pos_info cmd_pos() const { return m_last_cmd_pos; }
name const & get_cmd_token() const { return m_cmd_token; }
void set_line(unsigned p) { return m_scanner.set_line(p); }
expr mk_app(expr fn, expr arg, pos_info const & p);

20
src/library/declaration_index.cpp
View file

@ -8,18 +8,24 @@ Author: Leonardo de Moura
#include "library/declaration_index.h"
namespace lean {
void declaration_index::add_decl(std::string const fname, pos_info const & p, name const & n) {
m_entries.emplace_back(entry_kind::Declaration, fname, p, n);
void declaration_index::add_decl(std::string const fname, pos_info const & p, name const & n, name const & k, expr const & t) {
m_entries.emplace_back(entry_kind::Declaration, fname, p, n, k, t);
}
void declaration_index::add_ref(std::string const fname, pos_info const & p, name const & n) {
m_entries.emplace_back(entry_kind::Reference, fname, p, n);
m_entries.emplace_back(entry_kind::Reference, fname, p, n, name(), expr());
}
void declaration_index::save(std::ostream & out) const {
entry_kind k; std::string fname; pos_info p; name n;
void declaration_index::save(io_state_stream const & out) const {
entry_kind k; std::string fname; pos_info p; name n, dk; expr t;
for (auto const & e : m_entries) {
std::tie(k, fname, p, n) = e;
std::tie(k, fname, p, n, dk, t) = e;
out << (k == entry_kind::Declaration ? "d" : "r") << "|" << fname << "|" << p.first
<< "|" << p.second << "|" << n << std::endl;
<< "|" << p.second << "|" << n;
if (k == entry_kind::Declaration) {
out << "|" << dk << "|";
options const & opts = out.get_options();
out.get_stream() << mk_pair(flatten(out.get_formatter()(t)), opts);
}
out << endl;
}
}
}

8
src/library/declaration_index.h
View file

@ -10,17 +10,19 @@ Author: Leonardo de Moura
#include <utility>
#include <string>
#include "util/name.h"
#include "kernel/expr.h"
#include "kernel/pos_info_provider.h"
#include "library/io_state_stream.h"
namespace lean {
/** \brief Datastructure for storing where a given declaration was defined. */
class declaration_index {
enum class entry_kind { Declaration, Reference };
typedef std::tuple<entry_kind, std::string, pos_info, name> entry;
typedef std::tuple<entry_kind, std::string, pos_info, name, name, expr> entry;
std::vector<entry> m_entries;
public:
void add_decl(std::string const fname, pos_info const & p, name const & n);
void add_decl(std::string const fname, pos_info const & p, name const & n, name const & k, expr const & t);
void add_ref(std::string const fname, pos_info const & p, name const & n);
void save(std::ostream & out) const;
void save(io_state_stream const & out) const;
};
}

5
src/shell/lean.cpp
View file

@ -303,8 +303,9 @@ int main(int argc, char ** argv) {
cache.save(out);
}
if (gen_index) {
std::ofstream out(index_name);
index.save(out);
std::shared_ptr<lean::file_output_channel> out(new lean::file_output_channel(index_name.c_str()));
ios.set_regular_channel(out);
index.save(regular(env, ios));
}
if (export_objects && (permissive || ok)) {
std::ofstream out(output, std::ofstream::binary);