Rust: More type inference tests

Author: hvitved

rust/ql/test/library-tests/type-inference/closure.rs

@@ -152,3 +152,90 @@ mod dyn_fn_once {
         let _r2 = apply_boxed(Box::new(|_: i64| true), 3); // $ target=apply_boxed target=new type=_r2:bool
     }
 }
+
+mod closure_infer_param {
+    fn apply1<F: Fn(i64) -> i64>(f: F, a: i64) -> i64 {
+        f(a)
+    }
+
+    fn apply2(f: impl Fn(i64) -> i64, a: i64) -> i64 {
+        f(a)
+    }
+
+    fn apply3(f: &dyn Fn(i64) -> i64, a: i64) -> i64 {
+        f(a)
+    }
+
+    fn apply4<F: FnMut(i64) -> i64>(mut f: F, a: i64) -> i64 {
+        f(a)
+    }
+
+    fn apply5(f: &mut dyn FnMut(i64) -> i64, a: i64) -> i64 {
+        f(a)
+    }
+
+    fn apply6<T>(f: impl Fn(T) -> i64, a: T) -> i64 {
+        f(a)
+    }
+
+    fn apply7<T, F: FnMut(T) -> i64>(mut f: F, a: T) -> i64 {
+        f(a)
+    }
+
+    fn test() {
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply1(f, 1i64); // $ target=apply1
+
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply2(f, 2i64); // $ target=apply2
+
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply3(&f, 3i64); // $ target=apply3
+
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply4(f, 4i64); // $ target=apply4
+
+        let mut f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply5(&mut f, 5i64); // $ target=apply5
+
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply6(f, 6i64); // $ target=apply6
+
+        let f = |x| x; // $ MISSING: type=x:i64
+        let _r = apply7(f, 7i64); // $ target=apply7
+    }
+}
+
+mod implicit_deref {
+    use std::ops::Deref;
+
+    struct S<T>(T);
+
+    impl<T> Deref for S<T> {
+        type Target = dyn Fn(T) -> bool;
+
+        fn deref(&self) -> &Self::Target {
+            &|_| false
+        }
+    }
+
+    pub fn test() {
+        let x = 0i64;
+        let v = Default::default(); // $ MISSING: type=v:i64 target=default
+        let s = S(v);
+        let _ret = s(x); // $ MISSING: type=_ret:bool
+
+        let x = 0i32;
+        let v = Default::default(); // $ MISSING: type=v:i32 target=default
+        let s = S(v);
+        let s_ref = &s;
+        let _ret = s_ref(x); // $ MISSING: type=_ret:bool
+
+        // The call below is not an implicit deref, instead it will target
+        // `impl<A, F> FnOnce<A> for &F` from
+        // https://doc.rust-lang.org/std/ops/trait.FnOnce.html#impl-FnOnce%3CA%3E-for-%26F
+        // and we currently cannot handle inferring the output type
+        let c = |x| x; // $ MISSING: type=x:i64
+        (&c)(x); // $ MISSING: type=_:i64
+    }
+}

rust/ql/test/library-tests/type-inference/main.rs

@@ -2878,6 +2878,30 @@ mod closure;
 mod dereference;
 mod dyn_type;
 
+mod arg_trait_bounds {
+    struct Gen<T>(T);
+
+    trait Container<T> {
+        fn get_input(&self) -> T;
+    }
+
+    fn my_get<T: Container<i64>>(c: &T) -> bool {
+        c.get_input() == 42 // $ target=get_input target=eq
+    }
+
+    impl<GT: Copy> Container<GT> for Gen<GT> {
+        fn get_input(&self) -> GT {
+            self.0 // $ fieldof=Gen
+        }
+    }
+
+    fn test() {
+        let v = Default::default(); // $ MISSING: type=v:i64 target=default
+        let g = Gen(v);
+        let _ = my_get(&g); // $ target=my_get
+    }
+}
+
 fn main() {
     field_access::f(); // $ target=f
     method_impl::f(); // $ target=f