Methods and associated functions not found on types having nested generic type arguments

[ironcev]

E.g.:

fn foo<T>() {
    let o: Option<Option<T>> = None;
    let _ = o.is_none();
    //        ^^^^^^^ No method "is_none(Option<Option<T>>)" found for type "Option<Option<T>>".
    
    // Note that if we call the method without the '.' syntax it will be found.
    let _ = Option::is_none(o);
}

Here is a more comprehensive minimal repro that shows that the issue happens when the generic argument is itself generic. It also happens regardless if the final unknown generic is coming from the type of function/method definition:

library;

enum MyOption<T> {
    Some: T,
    None: (),
}

impl<T> MyOption<T> {
    fn new() -> Self {
        Self::None
    }

    fn is_none(self) -> bool {
        true
    }
}

fn generic_arg_in_function_method_call<T>() {
    let o: MyOption<u64> = MyOption::None;
    let _ = o.is_none(); // Ok.
    
    let o: MyOption<MyOption<u64>> = MyOption::None;
    let _ = o.is_none(); // Ok.

    let o: MyOption<T> = MyOption::None;
    let _ = o.is_none(); // Ok.
    
    let o: MyOption<MyOption<T>> = MyOption::None;
    // let _ = o.is_none();
    //           ^^^^^^^ No method "is_none(MyOption<MyOption<T>>)" found for type "MyOption<MyOption<T>>".
    
    let _ = MyOption::is_none(o); // Ok ;-)
}

fn generic_arg_in_function_associated_function_call<T>() {
    let _ = MyOption::<u64>::new(); // Ok.
    let o: MyOption<u64> = MyOption::new(); // Ok.
    
    let _ = MyOption::<MyOption<u64>>::new(); // Ok.
    let o: MyOption<MyOption<u64>> = MyOption::new(); // Ok.

    let _ = MyOption::<T>::new(); // Ok.
    let o: MyOption<T> = MyOption::new(); // Ok.
    
    let _ = MyOption::<MyOption<T>>::new();
    //                               ^^^ No method "new()" found for type "MyOption<MyOption<T>>".
    
    // // let o: MyOption<MyOption<T>> = MyOption::new();
    //                                ^^^^^^^^^^^^^^^ Mismatched types.
    // expected: MyOption<MyOption<T>>
    // found:    MyOption<T>.
    // help: Variable declaration's type annotation does not match up with the assigned expression's type.
}

struct S<T> { }

impl<T> S<T> {
    fn generic_arg_in_type() {
        let o: MyOption<u64> = MyOption::None;
        let _ = o.is_none(); // Ok.
        
        let o: MyOption<MyOption<u64>> = MyOption::None;
        let _ = o.is_none(); // Ok.
    
        let o: MyOption<T> = MyOption::None;
        let _ = o.is_none(); // Ok.
        
        let o: MyOption<MyOption<T>> = MyOption::None;
        // let _ = o.is_none();
        //           ^^^^^^^ No method "is_none(MyOption<MyOption<T>>)" found for type "MyOption<MyOption<T>>".
        
        let _ = MyOption::is_none(o); // Ok ;-)
    }
}

pub fn main() {
    generic_arg_in_function_method_call::<(())>();
    S::<()>::generic_arg_in_type();

    generic_arg_in_function_associated_function_call::<()>();
}

The issue is also reproducible on the current mainnet version 0.66.5.

Here are some real-life examples using types from the standard library that fail to compile.