Rust: More type inference tests

Author: hvitved

rust/ql/test/library-tests/type-inference/CONSISTENCY/PathResolutionConsistency.expected

@@ -2,3 +2,4 @@ multipleResolvedTargets
 | main.rs:2223:9:2223:31 | ... .my_add(...) |
 | main.rs:2225:9:2225:29 | ... .my_add(...) |
 | main.rs:2740:13:2740:17 | x.f() |
+| regressions.rs:179:17:179:27 | ... + ... |

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

@@ -2759,6 +2759,30 @@ mod dereference;
 mod dyn_type;
 mod regressions;
 
+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

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

@@ -130,3 +130,52 @@ mod regression4 {
         }
     }
 }
+
+mod regression5 {
+    struct S1;
+    struct S2<T2>(T2);
+
+    impl From<&S1> for S2<S1> {
+        fn from(_: &S1) -> Self {
+            S2(S1)
+        }
+    }
+
+    impl<T> From<T> for S2<T> {
+        fn from(t: T) -> Self {
+            S2(t)
+        }
+    }
+
+    fn foo() -> S2<S1> {
+        let x = S1.into(); // $ target=into
+        x
+    }
+}
+
+mod regression6 {
+    use std::ops::Add;
+    struct S<T>(T);
+
+    impl<T> Add for S<T> {
+        type Output = Self;
+
+        // add1
+        fn add(self, _rhs: Self) -> Self::Output {
+            self
+        }
+    }
+
+    impl<T> Add<T> for S<T> {
+        type Output = Self;
+
+        // add2
+        fn add(self, _rhs: T) -> Self::Output {
+            self
+        }
+    }
+
+    fn foo() {
+        let x = S(0) + S(1); // $ target=add1 $ SPURIOUS: target=add2 type=x:T.T.i32
+    }
+}