Implementation of traits on functions ignored after function call

In this example, I implement a trait on generic functions. One with mutability and one without. When invoked manually, the proper trait gets called. Instead, if I try to peel off the function's unique tag using another function, the traits are no longer visible.

Checked against: rustc 1.8.0-nightly (57c357d 2016-02-16)

trait FooFn {
    fn foo(&self);
}

impl<T: Sized> FooFn for fn(&mut T)-> T {
    fn foo(&self) {
        println!("Generic (with mutable) match!");
    }
}


impl<T: Sized> FooFn for fn(T)->T {
    fn foo(&self) {
        println!("Generic match!");

    }    
}

fn simple_fn(x: i32) -> i32 { 1 }
fn simple_fn2(x: &mut i32) -> i32 { 2 }

fn strip<T, U>(x: fn(T)->U) -> fn(T)->U { x }

fn main() {
    //Works
    &(simple_fn as fn(i32)->i32).foo(); 
    //Also works
    &(simple_fn2 as fn(&mut i32)->i32).foo();

    //Works
    strip(simple_fn).foo();
    //Error: no method named `foo` found for type `fn(&mut i32) -> i32`
    strip(simple_fn2).foo();
}

This is an unfortunate issue with late-bound regions.

Your impl is for the type for<'a> fn(&'a mut T) -> T, while strip forces T to be concrete, so you have fn(&'α mut T) -> T for some (specific) lifetime α.

I agree that the error message could be better.

@arielb1

@arielb1 Assuming I understand what you're saying, it seems like the more specific lifetime still inhabits the space of the more generic lifetimes that the impl covers. If that's true, I'd expect that functionality to still be available, even when it's concrete.

Or are you saying that mechanically the decision of whether the type has the impl available to it has to be made earlier than the nailing down of the lifetime?

The issue is fundamentally a type mismatch; there are two different kinds of "generic" lifetime. It tends to be a bit confusing, since the syntax is very similar, and there are implicit conversions in some cases, but the error is legitimate.

To illustrate:

trait FooFn {
    fn foo(&self);
}

impl FooFn for for<'a> fn(&'a mut i32)-> i32 {
    fn foo(&self) {
        println!("Generic (with mutable) match!");
    }
}

impl<'a> FooFn for fn(&'a mut i32)-> i32 {
    fn foo(&self) {
        println!("Generic lifetime match!");
    }
}

impl FooFn for fn(i32)->i32 {
    fn foo(&self) {
        println!("Generic match!");

    }    
}

fn simple_fn(x: i32) -> i32 { 1 }
fn simple_fn2(x: &mut i32) -> i32 { 2 }

fn strip(x: fn(i32)->i32) -> fn(i32)->i32 { x }
fn strip2(x: fn(&mut i32)->i32) -> fn(&mut i32)->i32 { x }
fn strip3<'a>(x: fn(&'a mut i32)->i32) -> fn(&'a mut i32)->i32 { x }
fn strip4(x: fn(&'static mut i32)->i32) -> fn(&'static mut i32)->i32 { x }

fn main() {
    &(simple_fn as fn(i32)->i32).foo(); 
    &(simple_fn2 as fn(&mut i32)->i32).foo();

    strip(simple_fn).foo();
    strip2(simple_fn2).foo();
    strip3(simple_fn2).foo();
    strip4(simple_fn2).foo();
}

cc @rust-lang/wg-diagnostics when reporting that a trait is not implemented for a type, we should also search for impls that only differ in lifetimes and explain why/how the lifetimes are different

Current output:

error[E0599]: no method named `foo` found for fn pointer `fn(&mut i32) -> i32` in the current scope
  --> f103.rs:33:23
   |
33 |     strip(simple_fn2).foo();
   |                       ^^^ method not found in `fn(&mut i32) -> i32`
   |
   = help: items from traits can only be used if the trait is implemented and in scope
note: `FooFn` defines an item `foo`, perhaps you need to implement it
  --> f103.rs:1:1
   |
1  | trait FooFn {
   | ^^^^^^^^^^^

We still don't do what oli suggested, and we should.

We already currently have logic to check for alternative impls:

rust/compiler/rustc_hir_typeck/src/method/suggest.rs

Lines 3543 to 3593 in 25d319a

    
           fn suggest_traits_to_import( 
        
               &self, 
        
               err: &mut Diag<'_>, 
        
               span: Span, 
        
               rcvr_ty: Ty<'tcx>, 
        
               item_name: Ident, 
        
               inputs_len: Option<usize>, 
        
               source: SelfSource<'tcx>, 
        
               valid_out_of_scope_traits: Vec<DefId>, 
        
               static_candidates: &[CandidateSource], 
        
               unsatisfied_bounds: bool, 
        
               return_type: Option<Ty<'tcx>>, 
        
               trait_missing_method: bool, 
        
           ) { 
        
               let mut alt_rcvr_sugg = false; 
        
               let mut trait_in_other_version_found = false; 
        
               if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) { 
        
                   debug!( 
        
                       "suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}", 
        
                       span, item_name, rcvr_ty, rcvr 
        
                   ); 
        
                   let skippable = [ 
        
                       self.tcx.lang_items().clone_trait(), 
        
                       self.tcx.lang_items().deref_trait(), 
        
                       self.tcx.lang_items().deref_mut_trait(), 
        
                       self.tcx.lang_items().drop_trait(), 
        
                       self.tcx.get_diagnostic_item(sym::AsRef), 
        
                   ]; 
        
                   // Try alternative arbitrary self types that could fulfill this call. 
        
                   // FIXME: probe for all types that *could* be arbitrary self-types, not 
        
                   // just this list. 
        
                   for (rcvr_ty, post, pin_call) in &[ 
        
                       (rcvr_ty, "", None), 
        
                       ( 
        
                           Ty::new_mut_ref(self.tcx, self.tcx.lifetimes.re_erased, rcvr_ty), 
        
                           "&mut ", 
        
                           Some("as_mut"), 
        
                       ), 
        
                       ( 
        
                           Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, rcvr_ty), 
        
                           "&", 
        
                           Some("as_ref"), 
        
                       ), 
        
                   ] { 
        
                       match self.lookup_probe_for_diagnostic( 
        
                           item_name, 
        
                           *rcvr_ty, 
        
                           rcvr, 
        
                           ProbeScope::AllTraits, 
        
                           return_type, 
        
                       ) {

that we could expand to account for alternative fn signatures.

can also try to use selection to ask the trait solver to find all impls that match if all lifetimes are replaced by infer vars

Something I did with

        if let Ok(Some(ImplSource::UserDefined(impl_data))) =
            SelectionContext::new(self).select(&obligation.with(self.tcx, trait_ref.skip_binder()))

in #148641

Navigation Menu

Repository navigation

Implementation of traits on functions ignored after function call #31730

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

	fn suggest_traits_to_import(
	&self,
	err: &mut Diag<'_>,
	span: Span,
	rcvr_ty: Ty<'tcx>,
	item_name: Ident,
	inputs_len: Option<usize>,
	source: SelfSource<'tcx>,
	valid_out_of_scope_traits: Vec<DefId>,
	static_candidates: &[CandidateSource],
	unsatisfied_bounds: bool,
	return_type: Option<Ty<'tcx>>,
	trait_missing_method: bool,
	) {
	let mut alt_rcvr_sugg = false;
	let mut trait_in_other_version_found = false;
	if let (SelfSource::MethodCall(rcvr), false) = (source, unsatisfied_bounds) {
	debug!(
	"suggest_traits_to_import: span={:?}, item_name={:?}, rcvr_ty={:?}, rcvr={:?}",
	span, item_name, rcvr_ty, rcvr
	);
	let skippable = [
	self.tcx.lang_items().clone_trait(),
	self.tcx.lang_items().deref_trait(),
	self.tcx.lang_items().deref_mut_trait(),
	self.tcx.lang_items().drop_trait(),
	self.tcx.get_diagnostic_item(sym::AsRef),
	];
	// Try alternative arbitrary self types that could fulfill this call.
	// FIXME: probe for all types that could be arbitrary self-types, not
	// just this list.
	for (rcvr_ty, post, pin_call) in &[
	(rcvr_ty, "", None),
	(
	Ty::new_mut_ref(self.tcx, self.tcx.lifetimes.re_erased, rcvr_ty),
	"&mut ",
	Some("as_mut"),
	),
	(
	Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, rcvr_ty),
	"&",
	Some("as_ref"),
	),
	] {
	match self.lookup_probe_for_diagnostic(
	item_name,
	*rcvr_ty,
	rcvr,
	ProbeScope::AllTraits,
	return_type,
	) {

Implementation of traits on functions ignored after function call #31730

Description

Activity

arielb1 commented on Feb 17, 2016

sophiajt commented on Feb 17, 2016

eefriedman commented on Feb 17, 2016

oli-obk commented on Jan 25, 2020

estebank commented on Feb 21, 2024

estebank commented on Nov 11, 2025

oli-obk commented on Nov 13, 2025

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions