102 lines
3.6 KiB
C++
102 lines
3.6 KiB
C++
/*
|
|
Copyright (c) 2018 Microsoft Corporation. All rights reserved.
|
|
Released under Apache 2.0 license as described in the file LICENSE.
|
|
Author: Leonardo de Moura
|
|
*/
|
|
#include "kernel/instantiate.h"
|
|
#include "library/util.h"
|
|
#include "library/compiler/util.h"
|
|
#include "library/compiler/export_attribute.h"
|
|
|
|
namespace lean {
|
|
#define REDUCE_ARITY_SUFFIX "_rarg"
|
|
|
|
name mk_reduce_arity_aux_fn(name const & n) {
|
|
return name(n, REDUCE_ARITY_SUFFIX);
|
|
}
|
|
|
|
bool is_reduce_arity_aux_fn(name const & n) {
|
|
return n.is_string() && !n.is_atomic() && strcmp(n.get_string().data(), REDUCE_ARITY_SUFFIX) == 0;
|
|
}
|
|
|
|
bool arity_was_reduced(comp_decl const & cdecl) {
|
|
expr v = cdecl.snd();
|
|
while (is_lambda(v))
|
|
v = binding_body(v);
|
|
expr const & f = get_app_fn(v);
|
|
if (!is_constant(f)) return false;
|
|
name const & n = const_name(f);
|
|
return is_reduce_arity_aux_fn(n) && n.get_prefix() == cdecl.fst();
|
|
}
|
|
|
|
comp_decls reduce_arity(environment const & env, comp_decl const & cdecl) {
|
|
if (has_export_name(env, cdecl.fst()) || cdecl.fst() == "main") {
|
|
/* We do not modify the arity of entry points (i.e., functions with attribute [export]) */
|
|
return comp_decls(cdecl);
|
|
}
|
|
expr code = cdecl.snd();
|
|
buffer<expr> fvars;
|
|
name_generator ngen;
|
|
local_ctx lctx;
|
|
while (is_lambda(code)) {
|
|
lean_assert(!has_loose_bvars(binding_domain(code)));
|
|
expr fvar = lctx.mk_local_decl(ngen, binding_name(code), binding_domain(code));
|
|
fvars.push_back(fvar);
|
|
code = binding_body(code);
|
|
}
|
|
code = instantiate_rev(code, fvars.size(), fvars.data());
|
|
buffer<expr> new_fvars;
|
|
#if 1
|
|
/* For now, we remove just the prefix.
|
|
Removing unused variables that occur in other parts of the declaration seem to create problems.
|
|
Example: we may create more closures if the function is partially applied.
|
|
By eliminating just a prefix, we get the most common case: a function that starts with a sequence of type variables.
|
|
TODO(Leo): improve this. */
|
|
bool found_used = false;
|
|
for (expr & fvar : fvars) {
|
|
if (found_used || has_fvar(code, fvar)) {
|
|
found_used = true;
|
|
new_fvars.push_back(fvar);
|
|
}
|
|
}
|
|
#else
|
|
for (expr & fvar : fvars) {
|
|
if (has_fvar(code, fvar)) {
|
|
new_fvars.push_back(fvar);
|
|
}
|
|
}
|
|
#endif
|
|
if (fvars.size() == new_fvars.size() || new_fvars.empty()) {
|
|
/* Do nothing if:
|
|
1- All arguments are used.
|
|
2- No argument was used, and auxiliary declaration would be a constant.
|
|
This is not safe since constants are executed during initialization,
|
|
and we may execute unreachable code when one of the "unused" arguments
|
|
is an uninhabited type. Here is an example where the auxiliary definition
|
|
would be a constant:
|
|
|
|
```
|
|
def false.elim {C : Sort u} (h : false) : C := ..
|
|
```
|
|
*/
|
|
return comp_decls(cdecl);
|
|
}
|
|
name red_fn = mk_reduce_arity_aux_fn(cdecl.fst());
|
|
expr red_code = lctx.mk_lambda(new_fvars, code);
|
|
comp_decl red_decl(red_fn, red_code);
|
|
/* Replace `cdecl` code with a call to `red_fn`.
|
|
We rely on inlining to reduce calls to `cdecl` into calls to `red_decl`. */
|
|
expr new_code = mk_app(mk_constant(red_fn), new_fvars);
|
|
new_code = try_eta(lctx.mk_lambda(fvars, new_code));
|
|
comp_decl new_decl(cdecl.fst(), new_code);
|
|
return comp_decls(red_decl, comp_decls(new_decl));
|
|
}
|
|
|
|
comp_decls reduce_arity(environment const & env, comp_decls const & ds) {
|
|
comp_decls r;
|
|
for (comp_decl const & d : ds) {
|
|
r = append(r, reduce_arity(env, d));
|
|
}
|
|
return r;
|
|
}
|
|
}
|