Incompletely allow overloaded call from opaque when self type bottoms out in infer

Author: compiler-errors

compiler/rustc_hir_typeck/src/callee.rs

@@ -14,7 +14,7 @@ use rustc_middle::ty::adjustment::{
 use rustc_middle::ty::{self, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{Ident, Span, sym};
+use rustc_span::{Ident, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::traits::DefIdOrName;
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
@@ -66,7 +66,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         arg_exprs: &'tcx [hir::Expr<'tcx>],
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
-        let original_callee_ty = match &callee_expr.kind {
+        let expr_ty = match &callee_expr.kind {
             hir::ExprKind::Path(hir::QPath::Resolved(..) | hir::QPath::TypeRelative(..)) => self
                 .check_expr_with_expectation_and_args(
                     callee_expr,
@@ -76,8 +76,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             _ => self.check_expr(callee_expr),
         };
 
-        let expr_ty = self.structurally_resolve_type(call_expr.span, original_callee_ty);
-
         let mut autoderef = self.autoderef(callee_expr.span, expr_ty);
         let mut result = None;
         while result.is_none() && autoderef.next().is_some() {
@@ -87,14 +85,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let output = match result {
             None => {
+                // First report an ambiguity error if possible.
+                let expr_ty = self.structurally_resolve_type(call_expr.span, expr_ty);
+
                 // this will report an error since original_callee_ty is not a fn
-                self.confirm_builtin_call(
-                    call_expr,
-                    callee_expr,
-                    original_callee_ty,
-                    arg_exprs,
-                    expected,
-                )
+                self.confirm_builtin_call(call_expr, callee_expr, expr_ty, arg_exprs, expected)
             }
 
             Some(CallStep::Builtin(callee_ty)) => {
@@ -129,7 +124,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         autoderef: &Autoderef<'a, 'tcx>,
     ) -> Option<CallStep<'tcx>> {
         let adjusted_ty =
-            self.structurally_resolve_type(autoderef.span(), autoderef.final_ty(false));
+            self.try_structurally_resolve_type(autoderef.span(), autoderef.final_ty(false));
 
         // If the callee is a bare function or a closure, then we're all set.
         match *adjusted_ty.kind() {
@@ -226,6 +221,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return None;
             }
 
+            // We only want to confirm a call step here if the infer var
+            // originated from the defining use of an opaque.
+            ty::Infer(ty::TyVar(vid))
+                if let Some(alias_ty) = self.find_sup_as_registered_opaque(vid) =>
+            {
+                return self
+                    .try_overloaded_call_traits_for_alias(call_expr, alias_ty, arg_exprs)
+                    .map(|(autoref, method)| {
+                        let mut adjustments = self.adjust_steps(autoderef);
+                        adjustments.extend(autoref);
+                        self.apply_adjustments(callee_expr, adjustments);
+                        CallStep::Overloaded(method)
+                    });
+            }
+
+            ty::Infer(_) => {
+                return None;
+            }
+
             ty::Error(_) => {
                 return None;
             }
@@ -290,40 +304,111 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Try the options that are least restrictive on the caller first.
         for (opt_trait_def_id, method_name, borrow) in call_trait_choices {
-            let Some(trait_def_id) = opt_trait_def_id else { continue };
+            if let Some(confirmed) = self.try_overloaded_call_trait(
+                call_expr,
+                adjusted_ty,
+                opt_arg_exprs,
+                opt_trait_def_id,
+                method_name,
+                borrow,
+            ) {
+                return Some(confirmed);
+            }
+        }
+
+        None
+    }
 
-            let opt_input_type = opt_arg_exprs.map(|arg_exprs| {
-                Ty::new_tup_from_iter(self.tcx, arg_exprs.iter().map(|e| self.next_ty_var(e.span)))
+    fn try_overloaded_call_trait(
+        &self,
+        call_expr: &hir::Expr<'_>,
+        call_ty: Ty<'tcx>,
+        opt_arg_exprs: Option<&'tcx [hir::Expr<'tcx>]>,
+        opt_trait_def_id: Option<DefId>,
+        method_name: Symbol,
+        borrow: bool,
+    ) -> Option<(Option<Adjustment<'tcx>>, MethodCallee<'tcx>)> {
+        let Some(trait_def_id) = opt_trait_def_id else {
+            return None;
+        };
+
+        let opt_input_type = opt_arg_exprs.map(|arg_exprs| {
+            Ty::new_tup_from_iter(self.tcx, arg_exprs.iter().map(|e| self.next_ty_var(e.span)))
+        });
+
+        let Some(ok) = self.lookup_method_in_trait(
+            self.misc(call_expr.span),
+            Ident::with_dummy_span(method_name),
+            trait_def_id,
+            call_ty,
+            opt_input_type,
+        ) else {
+            return None;
+        };
+        let method = self.register_infer_ok_obligations(ok);
+        let mut autoref = None;
+        if borrow {
+            // Check for &self vs &mut self in the method signature. Since this is either
+            // the Fn or FnMut trait, it should be one of those.
+            let ty::Ref(_, _, mutbl) = method.sig.inputs()[0].kind() else {
+                bug!("Expected `FnMut`/`Fn` to take receiver by-ref/by-mut")
+            };
+
+            // For initial two-phase borrow
+            // deployment, conservatively omit
+            // overloaded function call ops.
+            let mutbl = AutoBorrowMutability::new(*mutbl, AllowTwoPhase::No);
+
+            autoref = Some(Adjustment {
+                kind: Adjust::Borrow(AutoBorrow::Ref(mutbl)),
+                target: method.sig.inputs()[0],
             });
+        }
 
-            if let Some(ok) = self.lookup_method_in_trait(
-                self.misc(call_expr.span),
-                Ident::with_dummy_span(method_name),
-                trait_def_id,
-                adjusted_ty,
-                opt_input_type,
-            ) {
-                let method = self.register_infer_ok_obligations(ok);
-                let mut autoref = None;
-                if borrow {
-                    // Check for &self vs &mut self in the method signature. Since this is either
-                    // the Fn or FnMut trait, it should be one of those.
-                    let ty::Ref(_, _, mutbl) = method.sig.inputs()[0].kind() else {
-                        bug!("Expected `FnMut`/`Fn` to take receiver by-ref/by-mut")
-                    };
-
-                    // For initial two-phase borrow
-                    // deployment, conservatively omit
-                    // overloaded function call ops.
-                    let mutbl = AutoBorrowMutability::new(*mutbl, AllowTwoPhase::No);
-
-                    autoref = Some(Adjustment {
-                        kind: Adjust::Borrow(AutoBorrow::Ref(mutbl)),
-                        target: method.sig.inputs()[0],
-                    });
-                }
+        Some((autoref, method))
+    }
 
-                return Some((autoref, method));
+    fn try_overloaded_call_traits_for_alias(
+        &self,
+        call_expr: &'tcx hir::Expr<'tcx>,
+        alias_ty: ty::AliasTy<'tcx>,
+        arg_exprs: &'tcx [rustc_hir::Expr<'tcx>],
+    ) -> Option<(Option<Adjustment<'tcx>>, MethodCallee<'tcx>)> {
+        let call_ty = alias_ty.to_ty(self.tcx);
+
+        let call_traits = [
+            (self.tcx.lang_items().fn_trait(), sym::call, true),
+            (self.tcx.lang_items().fn_mut_trait(), sym::call_mut, true),
+            (self.tcx.lang_items().fn_once_trait(), sym::call_once, false),
+            (self.tcx.lang_items().async_fn_trait(), sym::async_call, true),
+            (self.tcx.lang_items().async_fn_mut_trait(), sym::async_call_mut, true),
+            (self.tcx.lang_items().async_fn_once_trait(), sym::async_call_once, false),
+        ];
+        // We only want to try a call trait if it shows up in the bounds
+        // of the opaque. We confirm the first one that shows up in the
+        // bounds list, which can lead to inference weirdness but doesn't
+        // matter today.
+        for clause in
+            self.tcx.item_self_bounds(alias_ty.def_id).iter_instantiated(self.tcx, alias_ty.args)
+        {
+            let Some(poly_trait_ref) = clause.as_trait_clause() else {
+                continue;
+            };
+
+            if let Some(&(opt_trait_def_id, method_name, borrow)) =
+                call_traits.iter().find(|(trait_def_id, _, _)| {
+                    trait_def_id.is_some_and(|trait_def_id| trait_def_id == poly_trait_ref.def_id())
+                })
+                && let Some(confirmed) = self.try_overloaded_call_trait(
+                    call_expr,
+                    call_ty,
+                    Some(arg_exprs),
+                    opt_trait_def_id,
+                    method_name,
+                    borrow,
+                )
+            {
+                return Some(confirmed);
             }
         }
 

compiler/rustc_infer/src/infer/mod.rs

@@ -964,6 +964,23 @@ impl<'tcx> InferCtxt<'tcx> {
         self.inner.borrow().opaque_type_storage.opaque_types.clone()
     }
 
+    pub fn find_sup_as_registered_opaque(&self, ty_vid: TyVid) -> Option<ty::AliasTy<'tcx>> {
+        let ty_sub_vid = self.sub_root_var(ty_vid);
+        let opaques = self.inner.borrow().opaque_type_storage.opaque_types.clone();
+        opaques
+            .into_iter()
+            .find(|(_, hidden_ty)| {
+                if let ty::Infer(ty::TyVar(hidden_vid)) = *hidden_ty.ty.kind()
+                    && self.sub_root_var(hidden_vid) == ty_sub_vid
+                {
+                    true
+                } else {
+                    false
+                }
+            })
+            .map(|(key, _)| ty::AliasTy::new_from_args(self.tcx, key.def_id.to_def_id(), key.args))
+    }
+
     #[inline(always)]
     pub fn can_define_opaque_ty(&self, id: impl Into<DefId>) -> bool {
         debug_assert!(!self.next_trait_solver());