/* Store parameter info for fn in \c pinfos and return the dependencies of the resulting type
(if compute_resulting_deps == true). */
static list<unsigned> get_core(type_context & ctx,
expr const & fn, buffer<param_info> & pinfos,
unsigned max_args, bool compute_resulting_deps) {
expr type = ctx.relaxed_try_to_pi(ctx.infer(fn));
type_context::tmp_locals locals(ctx);
unsigned i = 0;
while (is_pi(type)) {
if (i == max_args)
break;
expr local = locals.push_local_from_binding(type);
expr local_type = ctx.infer(local);
expr new_type = ctx.relaxed_try_to_pi(instantiate(binding_body(type), local));
bool is_prop = ctx.is_prop(local_type);
bool is_dep = !closed(binding_body(type));
pinfos.emplace_back(binding_info(type).is_implicit(),
binding_info(type).is_inst_implicit(),
is_prop, is_dep, collect_deps(local_type, locals.as_buffer()));
type = new_type;
i++;
}
if (compute_resulting_deps)
return collect_deps(type, locals.as_buffer());
else
return list<unsigned>();
}
/* Store subsingleton parameter info for fn in \c ssinfos */
static void get_ss_core(type_context & ctx, expr const & fn, buffer<ss_param_info> & ssinfos,
unsigned max_args) {
expr type = ctx.relaxed_try_to_pi(ctx.infer(fn));
type_context::tmp_locals locals(ctx);
unsigned i = 0;
while (is_pi(type)) {
if (i == max_args)
break;
expr local = locals.push_local_from_binding(type);
expr local_type = ctx.infer(local);
expr new_type = ctx.relaxed_try_to_pi(instantiate(binding_body(type), local));
bool spec = false;
bool is_prop = ctx.is_prop(local_type);
bool is_sub = is_prop;
if (!is_sub) {
// TODO(Leo): check if the following line is a performance bottleneck.
is_sub = static_cast<bool>(ctx.mk_subsingleton_instance(local_type));
}
ssinfos.emplace_back(spec, is_sub);
type = new_type;
i++;
}
}
static void trace_if_unsupported(type_context & ctx, expr const & fn,
buffer<expr> const & args, unsigned prefix_sz, ss_param_infos const & result) {
lean_assert(args.size() >= length(result));
if (!is_fun_info_trace_enabled())
return;
fun_info info = get_fun_info(ctx, fn, args.size());
buffer<param_info> pinfos;
to_buffer(info.get_params_info(), pinfos);
buffer<ss_param_info> ssinfos;
to_buffer(get_subsingleton_info(ctx, fn, args.size()), ssinfos);
lean_assert(pinfos.size() == ssinfos.size());
/* Check if all remaining arguments are nondependent or
dependent (but all forward dependencies are subsingletons) */
unsigned i = prefix_sz;
for (; i < pinfos.size(); i++) {
param_info const & pinfo = pinfos[i];
if (!pinfo.has_fwd_deps())
continue; /* nondependent argument */
if (has_nonsubsingleton_fwd_dep(i, pinfos, ssinfos))
break; /* failed i-th argument has a forward dependent that is not a prop nor a subsingleton */
}
if (i == pinfos.size())
return; // It is *cheap* case
/* Expensive case */
/* We generate a trace message IF it would be possible to compute more precise information.
That is, there is an argument that is a proposition and/or subsingleton, but
the corresponding pinfo is not a marked a prop/subsingleton.
*/
i = 0;
for (ss_param_info const & ssinfo : result) {
if (ssinfo.is_subsingleton())
continue;
expr arg_type = ctx.infer(args[i]);
if (ctx.mk_subsingleton_instance(arg_type)) {
lean_trace_fun_info(
tout() << "approximating function information for '" << fn
<< "', this may affect the effectiveness of the simplifier and congruence closure modules, "
<< "more precise information can be efficiently computed if all parameters are moved to the "
<< "beginning of the function\n";);
return;
}
bool is_comp_irrelevant(type_context & ctx, expr const & e) {
expr type = ctx.whnf(ctx.infer(e));
return is_sort(type) || ctx.is_prop(type);
}