@@ -10,7 +10,7 @@ use rustc_hir::def_id::DefId;
1010use rustc_hir:: intravisit:: Visitor ;
1111use rustc_hir:: { Expr , ExprKind , HirId , LangItem , Node , QPath , is_range_literal} ;
1212use rustc_hir_analysis:: check:: potentially_plural_count;
13- use rustc_hir_analysis:: hir_ty_lowering:: { HirTyLowerer , PermitVariants } ;
13+ use rustc_hir_analysis:: hir_ty_lowering:: { HirTyLowerer , IsMethodCall , PermitVariants } ;
1414use rustc_index:: IndexVec ;
1515use rustc_infer:: infer:: { BoundRegionConversionTime , DefineOpaqueTypes , InferOk , TypeTrace } ;
1616use rustc_middle:: ty:: adjustment:: AllowTwoPhase ;
@@ -195,6 +195,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
195195 call_span : Span ,
196196 // Expression of the call site
197197 call_expr : & ' tcx hir:: Expr < ' tcx > ,
198+ is_method : IsMethodCall ,
198199 // Types (as defined in the *signature* of the target function)
199200 formal_input_tys : & [ Ty < ' tcx > ] ,
200201 formal_output : Ty < ' tcx > ,
@@ -206,7 +207,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
206207 c_variadic : bool ,
207208 // Whether the arguments have been bundled in a tuple (ex: closures)
208209 tuple_arguments : TupleArgumentsFlag ,
209- // The DefId for the function being called, for better error messages
210+ // The DefId for the function being called, for callee bound checks and
211+ // better error messages
210212 fn_def_id : Option < DefId > ,
211213 ) {
212214 let tcx = self . tcx ;
@@ -326,8 +328,83 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
326328
327329 let mut err_code = E0061 ;
328330
331+ let mut expected_meets_callee_bounds = Vec :: with_capacity ( formal_input_tys. len ( ) ) ;
332+ expected_meets_callee_bounds. resize ( formal_input_tys. len ( ) , true ) ;
333+
334+ // Check whether the expected inputs satisfy the callee's where bounds.
335+ // This is skipped for the old solver: attempting trait solving there can
336+ // trigger an overflow, which is a fatal error in the old solver but is
337+ // treated as mere ambiguity by the next solver.
338+ if self . next_trait_solver ( )
339+ && let Some ( expected_input_tys) = & expected_input_tys
340+ && let Some ( fn_def_id) = fn_def_id
341+ // We don't need to check bounds for closures as they are already in the current
342+ // body's param env.
343+ && self . tcx . def_kind ( fn_def_id) != DefKind :: Closure
344+ {
345+ self . probe ( |_| {
346+ let new_args = self . fresh_args_for_item ( call_span, fn_def_id) ;
347+ let fn_sig = self . tcx . fn_sig ( fn_def_id) . instantiate ( self . tcx , new_args) ;
348+ let fn_sig = self . instantiate_binder_with_fresh_vars (
349+ call_span,
350+ BoundRegionConversionTime :: FnCall ,
351+ fn_sig,
352+ ) ;
353+ let ocx = ObligationCtxt :: new ( self ) ;
354+ let origin = self . misc ( call_span) ;
355+ let fn_sig = ocx. normalize ( & origin, self . param_env , fn_sig) ;
356+
357+ let bound_input_tys = fn_sig. inputs ( ) ;
358+ let bound_input_tys = if is_method == IsMethodCall :: Yes {
359+ & bound_input_tys[ 1 ..]
360+ } else {
361+ & bound_input_tys[ ..]
362+ } ;
363+
364+ let fn_bounds = self . tcx . predicates_of ( fn_def_id) . instantiate ( self . tcx , new_args) ;
365+ let fn_bounds = traits:: predicates_for_generics (
366+ |_, sp| self . misc ( sp) ,
367+ self . param_env ,
368+ fn_bounds,
369+ ) ;
370+ ocx. register_obligations ( fn_bounds) ;
371+
372+ // perf: We reuse this by cloning rather than repeating the above lines
373+ let preds = ocx. into_pending_obligations ( ) ;
374+
375+ assert_eq ! ( bound_input_tys. len( ) , formal_input_tys. len( ) , ) ;
376+ for idx in 0 ..formal_input_tys. len ( ) {
377+ let meets_bounds = self
378+ . probe ( |_| {
379+ let ocx = ObligationCtxt :: new ( self ) ;
380+ ocx. register_obligations ( preds. clone ( ) ) ;
381+ ocx. eq (
382+ & origin,
383+ self . param_env ,
384+ bound_input_tys[ idx] ,
385+ expected_input_tys[ idx] ,
386+ ) ?;
387+ if ocx. try_evaluate_obligations ( ) . is_empty ( ) {
388+ Ok ( ( ) )
389+ } else {
390+ Err ( TypeError :: Mismatch )
391+ }
392+ } )
393+ . is_ok ( ) ;
394+ expected_meets_callee_bounds[ idx] = meets_bounds;
395+ }
396+ } ) ;
397+ }
398+
329399 // If the arguments should be wrapped in a tuple (ex: closures), unwrap them here
330400 let ( formal_input_tys, expected_input_tys) = if tuple_arguments == TupleArguments {
401+ // Since the expected inputs are unpacked from a single tuple,
402+ // each input meets the callee bounds if and only if the tuple does.
403+ expected_meets_callee_bounds. resize (
404+ provided_args. len ( ) ,
405+ expected_meets_callee_bounds. first ( ) . copied ( ) . unwrap_or ( true ) ,
406+ ) ;
407+
331408 let tuple_type = self . structurally_resolve_type ( call_span, formal_input_tys[ 0 ] ) ;
332409 match tuple_type. kind ( ) {
333410 // We expected a tuple and got a tuple
@@ -390,7 +467,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
390467 // We're on the happy path here, so we'll do a more involved check and write back types
391468 // To check compatibility, we'll do 3 things:
392469 // 1. Unify the provided argument with the expected type
393- let expectation = Expectation :: rvalue_hint ( self , expected_input_ty) ;
470+ let expectation = if expected_meets_callee_bounds[ idx] {
471+ Expectation :: rvalue_hint ( self , expected_input_ty)
472+ } else {
473+ // If the expected input does not satisfy the callee's bounds, we must
474+ // weaken the expectation; otherwise, coercing to a type that violates
475+ // those bounds would result in a type mismatch.
476+ // See https://github.com/rust-lang/rust/issues/149379.
477+ Expectation :: ExpectRvalueLikeUnsized ( expected_input_ty)
478+ } ;
394479
395480 let checked_ty = self . check_expr_with_expectation ( provided_arg, expectation) ;
396481
0 commit comments