Merge #4958

4958: Infer FnSig via Fn traits r=flodiebold a=adamrk

Addresses #4481.
When inferring types check if the callee implements one of the builtin `Fn` traits. Also autoderef the callee before trying to figure out it's `FnSig`. 

Co-authored-by: adamrk <ark.email@gmail.com>

Author: bors[bot]

crates/ra_hir_ty/src/infer/expr.rs

@@ -10,12 +10,12 @@ use hir_def::{
     resolver::resolver_for_expr,
     AdtId, AssocContainerId, FieldId, Lookup,
 };
-use hir_expand::name::Name;
+use hir_expand::name::{name, Name};
 use ra_syntax::ast::RangeOp;
 
 use crate::{
     autoderef, method_resolution, op,
-    traits::InEnvironment,
+    traits::{FnTrait, InEnvironment},
     utils::{generics, variant_data, Generics},
     ApplicationTy, Binders, CallableDef, InferTy, IntTy, Mutability, Obligation, Rawness, Substs,
     TraitRef, Ty, TypeCtor,
@@ -63,6 +63,58 @@ impl<'a> InferenceContext<'a> {
         self.resolve_ty_as_possible(ty)
     }
 
+    fn callable_sig_from_fn_trait(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        let krate = self.resolver.krate()?;
+        let fn_once_trait = FnTrait::FnOnce.get_id(self.db, krate)?;
+        let output_assoc_type =
+            self.db.trait_data(fn_once_trait).associated_type_by_name(&name![Output])?;
+        let generic_params = generics(self.db.upcast(), fn_once_trait.into());
+        if generic_params.len() != 2 {
+            return None;
+        }
+
+        let mut param_builder = Substs::builder(num_args);
+        let mut arg_tys = vec![];
+        for _ in 0..num_args {
+            let arg = self.table.new_type_var();
+            param_builder = param_builder.push(arg.clone());
+            arg_tys.push(arg);
+        }
+        let parameters = param_builder.build();
+        let arg_ty = Ty::Apply(ApplicationTy {
+            ctor: TypeCtor::Tuple { cardinality: num_args as u16 },
+            parameters,
+        });
+        let substs = Substs::build_for_generics(&generic_params)
+            .push(ty.clone())
+            .push(arg_ty.clone())
+            .build();
+
+        let trait_env = Arc::clone(&self.trait_env);
+        let implements_fn_trait =
+            Obligation::Trait(TraitRef { trait_: fn_once_trait, substs: substs.clone() });
+        let goal = self.canonicalizer().canonicalize_obligation(InEnvironment {
+            value: implements_fn_trait.clone(),
+            environment: trait_env,
+        });
+        if self.db.trait_solve(krate, goal.value).is_some() {
+            self.obligations.push(implements_fn_trait);
+            let output_proj_ty =
+                crate::ProjectionTy { associated_ty: output_assoc_type, parameters: substs };
+            let return_ty = self.normalize_projection_ty(output_proj_ty);
+            Some((arg_tys, return_ty))
+        } else {
+            None
+        }
+    }
+
+    pub fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+        match ty.callable_sig(self.db) {
+            Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())),
+            None => self.callable_sig_from_fn_trait(ty, num_args),
+        }
+    }
+
     fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
         let body = Arc::clone(&self.body); // avoid borrow checker problem
         let ty = match &body[tgt_expr] {
@@ -198,14 +250,23 @@ impl<'a> InferenceContext<'a> {
             }
             Expr::Call { callee, args } => {
                 let callee_ty = self.infer_expr(*callee, &Expectation::none());
-                let (param_tys, ret_ty) = match callee_ty.callable_sig(self.db) {
-                    Some(sig) => (sig.params().to_vec(), sig.ret().clone()),
-                    None => {
-                        // Not callable
-                        // FIXME: report an error
-                        (Vec::new(), Ty::Unknown)
-                    }
-                };
+                let canonicalized = self.canonicalizer().canonicalize_ty(callee_ty.clone());
+                let mut derefs = autoderef(
+                    self.db,
+                    self.resolver.krate(),
+                    InEnvironment {
+                        value: canonicalized.value.clone(),
+                        environment: self.trait_env.clone(),
+                    },
+                );
+                let (param_tys, ret_ty): (Vec<Ty>, Ty) = derefs
+                    .find_map(|callee_deref_ty| {
+                        self.callable_sig(
+                            &canonicalized.decanonicalize_ty(callee_deref_ty.value),
+                            args.len(),
+                        )
+                    })
+                    .unwrap_or((Vec::new(), Ty::Unknown));
                 self.register_obligations_for_call(&callee_ty);
                 self.check_call_arguments(args, &param_tys);
                 self.normalize_associated_types_in(ret_ty)

crates/ra_hir_ty/src/tests/traits.rs

@@ -2888,3 +2888,226 @@ impl<A: Step> iter::Iterator for ops::Range<A> {
     );
     assert_eq!(t, "i32");
 }
+
+#[test]
+fn infer_closure_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo() {
+                let s = Option::None;
+                let f = |x: Option<i32>| {};
+                (&f)(s)
+            }
+        "#
+        ),
+        @r###"
+    137..259 '{     ...     }': ()
+    159..160 's': Option<i32>
+    163..175 'Option::None': Option<i32>
+    197..198 'f': |Option<i32>| -> ()
+    201..220 '|x: Op...2>| {}': |Option<i32>| -> ()
+    202..203 'x': Option<i32>
+    218..220 '{}': ()
+    238..245 '(&f)(s)': ()
+    239..241 '&f': &|Option<i32>| -> ()
+    240..241 'f': |Option<i32>| -> ()
+    243..244 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_fn_trait_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(&self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo<F, T>(f: F) -> T
+            where
+                F: Fn(Option<i32>) -> T,
+            {
+                let s = None;
+                f(s)
+            }
+        "#
+        ),
+        @r###"
+    183..187 'self': &Self
+    189..193 'args': Args
+    350..354 'self': &Self
+    356..360 'args': Args
+    515..516 'f': F
+    597..663 '{     ...     }': T
+    619..620 's': Option<i32>
+    623..627 'None': Option<i32>
+    645..646 'f': F
+    645..649 'f(s)': T
+    647..648 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_box_fn_arg() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+
+                fn deref(&self) -> &Self::Target;
+            }
+
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+
+            enum Option<T> {
+                None,
+                Some(T)
+            }
+
+            fn foo() {
+                let s = Option::None;
+                let f: Box<dyn FnOnce(&Option<i32>)> = box (|ps| {});
+                f(&s)
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    356..360 'self': &Self
+    622..626 'self': &Box<T>
+    634..685 '{     ...     }': &T
+    656..667 '&self.inner': &*mut T
+    657..661 'self': &Box<T>
+    657..667 'self.inner': *mut T
+    812..957 '{     ...     }': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    834..835 's': Option<i32>
+    838..850 'Option::None': Option<i32>
+    872..873 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    907..920 'box (|ps| {})': Box<|{unknown}| -> ()>
+    912..919 '|ps| {}': |{unknown}| -> ()
+    913..915 'ps': {unknown}
+    917..919 '{}': ()
+    938..939 'f': Box<dyn FnOnce<(&Option<i32>,)>>
+    938..943 'f(&s)': FnOnce::Output<dyn FnOnce<(&Option<i32>,)>, (&Option<i32>,)>
+    940..942 '&s': &Option<i32>
+    941..942 's': Option<i32>
+    "###
+    );
+}
+
+#[test]
+fn infer_dyn_fn_output() {
+    assert_snapshot!(
+        infer(
+            r#"
+            //- /lib.rs deps:std
+
+            #[lang = "fn_once"]
+            pub trait FnOnce<Args> {
+                type Output;
+
+                extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "fn"]
+            pub trait Fn<Args>:FnOnce<Args> {
+                extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+            }
+
+            #[lang = "deref"]
+            pub trait Deref {
+                type Target: ?Sized;
+
+                fn deref(&self) -> &Self::Target;
+            }
+
+            #[lang = "owned_box"]
+            pub struct Box<T: ?Sized> {
+                inner: *mut T,
+            }
+
+            impl<T: ?Sized> Deref for Box<T> {
+                type Target = T;
+
+                fn deref(&self) -> &T {
+                    &self.inner
+                }
+            }
+
+            fn foo() {
+                let f: Box<dyn Fn() -> i32> = box(|| 5);
+                let x = f();
+            }
+        "#
+        ),
+        @r###"
+    182..186 'self': Self
+    188..192 'args': Args
+    349..353 'self': &Self
+    355..359 'args': Args
+    523..527 'self': &Self
+    789..793 'self': &Box<T>
+    801..852 '{     ...     }': &T
+    823..834 '&self.inner': &*mut T
+    824..828 'self': &Box<T>
+    824..834 'self.inner': *mut T
+    889..990 '{     ...     }': ()
+    911..912 'f': Box<dyn Fn<(), Output = i32>>
+    937..946 'box(|| 5)': Box<|| -> i32>
+    941..945 '|| 5': || -> i32
+    944..945 '5': i32
+    968..969 'x': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    972..973 'f': Box<dyn Fn<(), Output = i32>>
+    972..975 'f()': FnOnce::Output<dyn Fn<(), Output = i32>, ()>
+    "###
+    );
+}

crates/ra_hir_ty/src/traits.rs

@@ -2,7 +2,9 @@
 use std::{panic, sync::Arc};
 
 use chalk_ir::cast::Cast;
-use hir_def::{expr::ExprId, DefWithBodyId, ImplId, TraitId, TypeAliasId};
+use hir_def::{
+    expr::ExprId, lang_item::LangItemTarget, DefWithBodyId, ImplId, TraitId, TypeAliasId,
+};
 use ra_db::{impl_intern_key, salsa, CrateId};
 use ra_prof::profile;
 use rustc_hash::FxHashSet;
@@ -298,6 +300,14 @@ impl FnTrait {
             FnTrait::Fn => "fn",
         }
     }
+
+    pub fn get_id(&self, db: &dyn HirDatabase, krate: CrateId) -> Option<TraitId> {
+        let target = db.lang_item(krate, self.lang_item_name().into())?;
+        match target {
+            LangItemTarget::TraitId(t) => Some(t),
+            _ => None,
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]