Pass host param in method_autoderef_steps

Author: compiler-errors

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -30,6 +30,7 @@ pub struct Autoderef<'a, 'tcx> {
     span: Span,
     body_id: LocalDefId,
     param_env: ty::ParamEnv<'tcx>,
+    host_effect_param: ty::Const<'tcx>,
 
     // Current state:
     state: AutoderefSnapshot<'tcx>,
@@ -112,6 +113,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         body_id: LocalDefId,
         span: Span,
         base_ty: Ty<'tcx>,
+        host_effect_param: ty::Const<'tcx>,
     ) -> Autoderef<'a, 'tcx> {
         Autoderef {
             infcx,
@@ -127,6 +129,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             },
             include_raw_pointers: false,
             silence_errors: false,
+            host_effect_param,
         }
     }
 
@@ -140,11 +143,8 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         // FIXME(effects): This is still broken, since we don't necessarily have a choice of
         // `host = true` or `host = host` in `const` functions. This is also busted in `method_autoderef_steps`.
         let deref_generics = self.infcx.tcx.generics_of(deref_trait_def_id);
-        let args = if let Some(host_param) = deref_generics.host_effect_index {
-            self.infcx.tcx.mk_args(&[
-                ty.into(),
-                self.infcx.var_for_def(self.span, &deref_generics.params[host_param]),
-            ])
+        let args = if deref_generics.host_effect_index.is_some() {
+            self.infcx.tcx.mk_args(&[ty.into(), self.host_effect_param.into()])
         } else {
             self.infcx.tcx.mk_args(&[ty.into()])
         };

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1644,7 +1644,14 @@ fn receiver_is_valid<'tcx>(
         return true;
     }
 
-    let mut autoderef = Autoderef::new(infcx, wfcx.param_env, wfcx.body_def_id, span, receiver_ty);
+    let mut autoderef = Autoderef::new(
+        infcx,
+        wfcx.param_env,
+        wfcx.body_def_id,
+        span,
+        receiver_ty,
+        tcx.expected_host_effect_param_for_body(wfcx.body_def_id),
+    );
 
     // The `arbitrary_self_types` feature allows raw pointer receivers like `self: *const Self`.
     if arbitrary_self_types_enabled {

compiler/rustc_hir_typeck/src/autoderef.rs

@@ -12,7 +12,14 @@ use std::iter;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub fn autoderef(&'a self, span: Span, base_ty: Ty<'tcx>) -> Autoderef<'a, 'tcx> {
-        Autoderef::new(self, self.param_env, self.body_id, span, base_ty)
+        Autoderef::new(
+            self,
+            self.param_env,
+            self.body_id,
+            span,
+            base_ty,
+            self.tcx.expected_host_effect_param_for_body(self.body_id),
+        )
     }
 
     pub fn try_overloaded_deref(

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -17,6 +17,8 @@ use rustc_infer::infer::DefineOpaqueTypes;
 use rustc_infer::infer::{self, InferOk, TyCtxtInferExt};
 use rustc_middle::middle::stability;
 use rustc_middle::query::Providers;
+use rustc_middle::traits::query::type_op::MethodAutoderef;
+use rustc_middle::traits::query::CanonicalMethodAutoderefGoal;
 use rustc_middle::ty::fast_reject::{simplify_type, TreatParams};
 use rustc_middle::ty::AssocItem;
 use rustc_middle::ty::GenericParamDefKind;
@@ -36,7 +38,6 @@ use rustc_trait_selection::traits::query::method_autoderef::MethodAutoderefBadTy
 use rustc_trait_selection::traits::query::method_autoderef::{
     CandidateStep, MethodAutoderefStepsResult,
 };
-use rustc_trait_selection::traits::query::CanonicalTyGoal;
 use rustc_trait_selection::traits::NormalizeExt;
 use rustc_trait_selection::traits::{self, ObligationCause};
 use std::cell::RefCell;
@@ -371,34 +372,32 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         OP: FnOnce(ProbeContext<'_, 'tcx>) -> Result<R, MethodError<'tcx>>,
     {
         let mut orig_values = OriginalQueryValues::default();
-        let param_env_and_self_ty = self.canonicalize_query(
-            ParamEnvAnd { param_env: self.param_env, value: self_ty },
-            &mut orig_values,
-        );
+        let goal = MethodAutoderef {
+            self_ty,
+            host_effect_param: self.tcx.expected_host_effect_param_for_body(self.body_id),
+        };
+        let canonical_goal = self.canonicalize_query(self.param_env.and(goal), &mut orig_values);
 
         let steps = match mode {
-            Mode::MethodCall => self.tcx.method_autoderef_steps(param_env_and_self_ty),
+            Mode::MethodCall => self.tcx.method_autoderef_steps(canonical_goal),
             Mode::Path => self.probe(|_| {
                 // Mode::Path - the deref steps is "trivial". This turns
                 // our CanonicalQuery into a "trivial" QueryResponse. This
                 // is a bit inefficient, but I don't think that writing
                 // special handling for this "trivial case" is a good idea.
 
                 let infcx = &self.infcx;
-                let (ParamEnvAnd { param_env: _, value: self_ty }, canonical_inference_vars) =
-                    infcx.instantiate_canonical_with_fresh_inference_vars(
-                        span,
-                        &param_env_and_self_ty,
-                    );
+                let (ParamEnvAnd { param_env: _, value: goal }, canonical_inference_vars) =
+                    infcx.instantiate_canonical_with_fresh_inference_vars(span, &canonical_goal);
                 debug!(
-                    "probe_op: Mode::Path, param_env_and_self_ty={:?} self_ty={:?}",
-                    param_env_and_self_ty, self_ty
+                    "probe_op: Mode::Path, canonical_goal={:?} self_ty={:?}",
+                    canonical_goal, self_ty
                 );
                 MethodAutoderefStepsResult {
                     steps: infcx.tcx.arena.alloc_from_iter([CandidateStep {
                         self_ty: self.make_query_response_ignoring_pending_obligations(
                             canonical_inference_vars,
-                            self_ty,
+                            goal.self_ty,
                         ),
                         autoderefs: 0,
                         from_unsafe_deref: false,
@@ -510,17 +509,23 @@ pub fn provide(providers: &mut Providers) {
 
 fn method_autoderef_steps<'tcx>(
     tcx: TyCtxt<'tcx>,
-    goal: CanonicalTyGoal<'tcx>,
+    goal: CanonicalMethodAutoderefGoal<'tcx>,
 ) -> MethodAutoderefStepsResult<'tcx> {
     debug!("method_autoderef_steps({:?})", goal);
 
     let (ref infcx, goal, inference_vars) = tcx.infer_ctxt().build_with_canonical(DUMMY_SP, &goal);
-    let ParamEnvAnd { param_env, value: self_ty } = goal;
-
-    let mut autoderef =
-        Autoderef::new(infcx, param_env, hir::def_id::CRATE_DEF_ID, DUMMY_SP, self_ty)
-            .include_raw_pointers()
-            .silence_errors();
+    let ParamEnvAnd { param_env, value: MethodAutoderef { self_ty, host_effect_param } } = goal;
+
+    let mut autoderef = Autoderef::new(
+        infcx,
+        param_env,
+        hir::def_id::CRATE_DEF_ID,
+        DUMMY_SP,
+        self_ty,
+        host_effect_param,
+    )
+    .include_raw_pointers()
+    .silence_errors();
     let mut reached_raw_pointer = false;
     let mut steps: Vec<_> = autoderef
         .by_ref()

compiler/rustc_middle/src/query/mod.rs

@@ -30,7 +30,7 @@ use crate::query::plumbing::{
 };
 use crate::thir;
 use crate::traits::query::{
-    CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
+    CanonicalMethodAutoderefGoal, CanonicalPredicateGoal, CanonicalProjectionGoal, CanonicalTyGoal,
     CanonicalTypeOpAscribeUserTypeGoal, CanonicalTypeOpEqGoal, CanonicalTypeOpNormalizeGoal,
     CanonicalTypeOpProvePredicateGoal, CanonicalTypeOpSubtypeGoal, NoSolution,
 };
@@ -2077,9 +2077,9 @@ rustc_queries! {
     }
 
     query method_autoderef_steps(
-        goal: CanonicalTyGoal<'tcx>
+        goal: CanonicalMethodAutoderefGoal<'tcx>
     ) -> MethodAutoderefStepsResult<'tcx> {
-        desc { "computing autoderef types for `{}`", goal.value.value }
+        desc { "computing autoderef types for `{}`", goal.value.value.self_ty }
     }
 
     query supported_target_features(_: CrateNum) -> &'tcx FxHashMap<String, Option<Symbol>> {

compiler/rustc_middle/src/traits/query.rs

@@ -14,7 +14,7 @@ use rustc_span::Span;
 
 pub mod type_op {
     use crate::ty::fold::TypeFoldable;
-    use crate::ty::{Predicate, Ty, TyCtxt, UserType};
+    use crate::ty::{Const, Predicate, Ty, TyCtxt, UserType};
     use std::fmt;
 
     #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable, TypeFoldable, TypeVisitable)]
@@ -65,12 +65,23 @@ pub mod type_op {
             Self { value }
         }
     }
+
+    #[derive(Copy, Clone, Debug, Hash, PartialEq, Eq, HashStable, TypeFoldable, TypeVisitable)]
+    pub struct MethodAutoderef<'tcx> {
+        pub self_ty: Ty<'tcx>,
+        /// Expected host effect value of the caller. For const fns, it's
+        /// some const param ty, and for normal functions, it's `true`.
+        pub host_effect_param: Const<'tcx>,
+    }
 }
 
 pub type CanonicalProjectionGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, ty::AliasTy<'tcx>>>;
 
 pub type CanonicalTyGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, Ty<'tcx>>>;
 
+pub type CanonicalMethodAutoderefGoal<'tcx> =
+    Canonical<'tcx, ty::ParamEnvAnd<'tcx, type_op::MethodAutoderef<'tcx>>>;
+
 pub type CanonicalPredicateGoal<'tcx> = Canonical<'tcx, ty::ParamEnvAnd<'tcx, ty::Predicate<'tcx>>>;
 
 pub type CanonicalTypeOpAscribeUserTypeGoal<'tcx> =

compiler/rustc_middle/src/ty/util.rs

@@ -804,10 +804,12 @@ impl<'tcx> TyCtxt<'tcx> {
                 self.consts.false_
             }
             Some(hir::ConstContext::ConstFn) => {
-                let host_idx = self
-                    .generics_of(def_id)
-                    .host_effect_index
-                    .expect("ConstContext::Maybe must have host effect param");
+                let host_idx = self.generics_of(def_id).host_effect_index.unwrap_or_else(|| {
+                    span_bug!(
+                        self.def_span(def_id),
+                        "item with `ConstContext::Maybe` must have host effect param"
+                    )
+                });
                 ty::GenericArgs::identity_for_item(self, def_id).const_at(host_idx)
             }
             None => self.consts.true_,

tests/ui/rfcs/rfc-2632-const-trait-impl/effects/const_closure-const_trait_impl-ice-113381.rs

@@ -1,3 +1,9 @@
+// known-bug: unknown
+// failure-status: 101
+// dont-check-compiler-stderr
+
+// const closures don't have host params...
+
 #![feature(const_closures, const_trait_impl, effects)]
 #![allow(incomplete_features)]
 
@@ -11,5 +17,4 @@ impl Foo for () {
 
 fn main() {
     (const || { (()).foo() })();
-    //~^ ERROR: cannot call non-const fn
 }

tests/ui/rfcs/rfc-2632-const-trait-impl/effects/minicore.rs

@@ -1,4 +1,4 @@
-// known-bug: unknown
+// check-pass
 
 #![crate_type = "lib"]
 #![feature(no_core, lang_items, unboxed_closures, auto_traits, intrinsics, rustc_attrs)]