Const functions' effect parameter is early-bound, leading to them only satisfying const Fn bounds

[compiler-errors]

I tried this code:

#![crate_type = "lib"]
#![allow(internal_features)]
#![no_std]
#![no_core]
#![feature(
    auto_traits,
    const_trait_impl,
    effects,
    lang_items,
    no_core,
    staged_api,
    unboxed_closures,
)]
#![stable(feature = "minicore", since = "1.0.0")]

fn test() {
    fn is_const_fn<F>(_: F)
    where
        F: const FnOnce<()>,
    {}

    const fn foo() {}

    is_const_fn(foo); // (*) See description in thread.
}

/// ---------------------------------------------------------------------- ///
/// Const fn trait definitions

#[const_trait]
#[lang = "fn"]
#[rustc_paren_sugar]
trait Fn<Args: Tuple>: ~const FnMut<Args> {
    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}

#[const_trait]
#[lang = "fn_mut"]
#[rustc_paren_sugar]
trait FnMut<Args: Tuple>: ~const FnOnce<Args> {
    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}

#[const_trait]
#[lang = "fn_once"]
#[rustc_paren_sugar]
trait FnOnce<Args: Tuple> {
    #[lang = "fn_once_output"]
    type Output;

    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}

/// ---------------------------------------------------------------------- ///
/// All this other stuff needed for core. Unrelated to test.

#[lang = "destruct"]
#[const_trait]
trait Destruct {}

#[lang = "freeze"]
unsafe auto trait Freeze {}

#[lang = "drop"]
#[const_trait]
trait Drop {
    fn drop(&mut self);
}

#[lang = "sized"]
trait Sized {}
#[lang = "copy"]
trait Copy {}

#[lang = "tuple_trait"]
trait Tuple {}

#[lang = "receiver"]
trait Receiver {}

impl<T: ?Sized> Receiver for &T {}

impl<T: ?Sized> Receiver for &mut T {}

[compiler-errors]

(*)

When we instantiate the path foo above, it turns into foo::<?0e>, with an effect infer var. When we select foo::<?0e>: Fn<(), false>, where false is the host parameter, this constrains ?0e to be false as well.

Unfortunately, checking foo::<?0e>: Fn<(), false> requires us to also check foo::<?0e>: Fn<(), true>, due to this code:

rust/compiler/rustc_hir_analysis/src/collect/predicates_of.rs

Lines 41 to 61 in 75c68cf

	let non_const_bound = if tcx.features().effects && tcx.has_attr(def_id, sym::const_trait) {
	// when `Self` is a const trait, also add `Self: Trait<.., true>` as implied bound,
	// because only implementing `Self: Trait<.., false>` is currently not possible.
	Some((
	ty::TraitRef::new(
	tcx,
	def_id,
	ty::GenericArgs::for_item(tcx, def_id, |param, _| {
	if param.is_host_effect() {
	tcx.consts.true_.into()
	} else {
	tcx.mk_param_from_def(param)
	}
	}),
	)
	.to_predicate(tcx),
	span,
	))
	} else {
	None
	};

This causes our previously constrained ?0e = false param to be equated to true, leading to a type error.

---

It turns out that const fn paths only implement one of const Fn() or Fn(). I don't believe there's a good way to make them implement both, since the effect parameter in a const fn is early-bound, and that effect param must agree with the constness of the Fn trait it's being proven to implement.

I'm not certain how we expect to reconcile the early-boundness of host parameters with the conceptual late-boundness of the constness effect being enforced at call sites. This doesn't seem concordant either with the fact that the host parameter is observable at monomorphization time via const_eval_select.

[compiler-errors]

Notably, this bug prevents me from turning the implementation of const_eval_select into something that looks like:

pub fn const_eval_select<ARG: Tuple, F, G, RET>(
        arg: ARG,
        called_in_const: F,
        called_at_rt: G,
    ) -> RET
    where
        F: const FnOnce<ARG, Output = RET>,
        G: FnOnce<ARG, Output = RET>;

which accurately reflects the type checking of calling such an intrinsic. Fixing this would also allow me to remove the gross manual logic of faea6ad, which manually registers the correct const projection bound and doesn't even try to register the trait bound const FnOnce due to its manual checking of the TyKind::FnDef.