Rust: Add type inference tests

Author: hvitved

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

@@ -1,8 +1,10 @@
 multipleCallTargets
-| dereference.rs:61:15:61:24 | e1.deref() |
-| main.rs:2308:13:2308:31 | ...::from(...) |
-| main.rs:2309:13:2309:31 | ...::from(...) |
-| main.rs:2310:13:2310:31 | ...::from(...) |
-| main.rs:2316:13:2316:31 | ...::from(...) |
-| main.rs:2317:13:2317:31 | ...::from(...) |
-| main.rs:2318:13:2318:31 | ...::from(...) |
+| dereference.rs:69:15:69:24 | e1.deref() |
+| dereference.rs:186:17:186:25 | S.bar(...) |
+| dereference.rs:187:17:187:29 | S.bar(...) |
+| main.rs:2323:13:2323:31 | ...::from(...) |
+| main.rs:2324:13:2324:31 | ...::from(...) |
+| main.rs:2325:13:2325:31 | ...::from(...) |
+| main.rs:2331:13:2331:31 | ...::from(...) |
+| main.rs:2332:13:2332:31 | ...::from(...) |
+| main.rs:2333:13:2333:31 | ...::from(...) |

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

@@ -27,6 +27,14 @@ impl<T> Deref for MySmartPointer<T> {
     }
 }
 
+struct S<T>(T);
+
+impl<T> S<T> {
+    fn foo(&self) -> &T {
+        &self.0 // $ fieldof=S
+    }
+}
+
 fn explicit_monomorphic_dereference() {
     // Dereference with method call
     let a1 = MyIntPointer { value: 34i64 };
@@ -91,6 +99,9 @@ fn implicit_dereference() {
     // Call method on implicitly dereferenced value
     let x = MySmartPointer { value: 34i64 };
     let _y = x.is_positive(); // $ MISSING: target=is_positive type=_y:bool
+
+    let z = MySmartPointer { value: S(0i64) };
+    let z_ = z.foo(); // $ MISSING: target=foo type=z_:&T.i64
 }
 
 mod implicit_deref_coercion_cycle {
@@ -128,11 +139,90 @@ mod implicit_deref_coercion_cycle {
     }
 }
 
+mod ref_vs_mut_ref {
+    trait MyTrait1<T> {
+        fn foo(self) -> T;
+    }
+
+    struct S;
+
+    impl MyTrait1<S> for &S {
+        // MyTrait1::foo1
+        fn foo(self) -> S {
+            S
+        }
+    }
+
+    impl MyTrait1<i64> for &mut S {
+        // MyTrait1::foo2
+        fn foo(self) -> i64 {
+            42
+        }
+    }
+
+    trait MyTrait2<T1, T2> {
+        fn bar(self, arg: T1) -> T2;
+    }
+
+    impl MyTrait2<&S, S> for S {
+        // MyTrait2::bar1
+        fn bar(self, arg: &S) -> S {
+            S
+        }
+    }
+
+    impl MyTrait2<&mut S, i64> for S {
+        // MyTrait2::bar2
+        fn bar(self, arg: &mut S) -> i64 {
+            42
+        }
+    }
+
+    pub fn test() {
+        let x = (&S).foo(); // $ MISSING: target=MyTrait1::foo1 type=x:S
+        let y = S.foo(); // $ MISSING: target=MyTrait1::foo1 type=y:S
+        let z = (&mut S).foo(); // $ MISSING: target=MyTrait1::foo2 type=z:i64
+
+        let x = S.bar(&S); // $ target=MyTrait2::bar1 type=x:S $ SPURIOUS: target=MyTrait2::bar2
+        let y = S.bar(&mut S); // $ target=MyTrait2::bar2 type=y:i64 $ SPURIOUS: target=MyTrait2::bar1
+    }
+}
+
+// from https://doc.rust-lang.org/reference/expressions/method-call-expr.html#r-expr.method.candidate-search
+mod rust_reference_example {
+    struct Foo {}
+
+    trait Bar {
+        fn bar(&self);
+    }
+
+    impl Foo {
+        // bar1
+        fn bar(&mut self) {
+            println!("In struct impl!")
+        }
+    }
+
+    impl Bar for Foo {
+        // bar2
+        fn bar(&self) {
+            println!("In trait impl!")
+        }
+    }
+
+    pub fn main() {
+        let mut f = Foo {};
+        f.bar(); // $ SPURIOUS: target=bar1 $ MISSING: target=bar2
+    }
+}
+
 pub fn test() {
     explicit_monomorphic_dereference(); // $ target=explicit_monomorphic_dereference
     explicit_polymorphic_dereference(); // $ target=explicit_polymorphic_dereference
     explicit_ref_dereference(); // $ target=explicit_ref_dereference
     explicit_box_dereference(); // $ target=explicit_box_dereference
     implicit_dereference(); // $ target=implicit_dereference
     implicit_deref_coercion_cycle::test(); // $ target=test
+    ref_vs_mut_ref::test(); // $ target=test
+    rust_reference_example::main(); // $ target=main
 }

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

@@ -909,36 +909,36 @@ mod generic_enum {
 }
 
 mod method_supertraits {
-    #[derive(Debug)]
+    #[derive(Debug, Clone, Copy)]
     struct MyThing<A> {
         a: A,
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Clone, Copy)]
     struct MyThing2<A> {
         a: A,
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Clone, Copy)]
     struct S1;
-    #[derive(Debug)]
+    #[derive(Debug, Clone, Copy)]
     struct S2;
 
     trait MyTrait1<Tr1> {
         // MyTrait1::m1
         fn m1(self) -> Tr1;
     }
 
-    trait MyTrait2<Tr2>: MyTrait1<Tr2> {
+    trait MyTrait2<Tr2>: MyTrait1<Tr2> + Copy {
         #[rustfmt::skip]
-        fn m2(self) -> Tr2
+        fn m2(&self) -> Tr2
         where
             Self: Sized,
         {
             if 3 > 2 { // $ target=gt
                 self.m1() // $ target=MyTrait1::m1
             } else {
-                Self::m1(self) // $ target=MyTrait1::m1
+                Self::m1(*self) // $ target=deref target=MyTrait1::m1
             }
         }
     }
@@ -952,7 +952,7 @@ mod method_supertraits {
             if 3 > 2 { // $ target=gt
                 self.m2().a // $ target=m2 $ fieldof=MyThing
             } else {
-                Self::m2(self).a // $ target=m2 fieldof=MyThing
+                Self::m2(&self).a // $ target=m2 fieldof=MyThing
             }
         }
     }
@@ -964,7 +964,7 @@ mod method_supertraits {
         }
     }
 
-    impl<T> MyTrait2<T> for MyThing<T> {}
+    impl<T: Copy> MyTrait2<T> for MyThing<T> {}
 
     impl<T> MyTrait1<MyThing<T>> for MyThing2<T> {
         // MyThing2::m1
@@ -973,9 +973,9 @@ mod method_supertraits {
         }
     }
 
-    impl<T> MyTrait2<MyThing<T>> for MyThing2<T> {}
+    impl<T: Copy> MyTrait2<MyThing<T>> for MyThing2<T> {}
 
-    impl<T> MyTrait3<T> for MyThing2<T> {}
+    impl<T: Copy> MyTrait3<T> for MyThing2<T> {}
 
     fn call_trait_m1<T1, T2: MyTrait1<T1>>(x: T2) -> T1 {
         x.m1() // $ target=MyTrait1::m1
@@ -1770,6 +1770,11 @@ mod overloadable_operators {
             self.x >= other.x && self.y >= other.y // $ fieldof=Vec2 target=ge
         }
     }
+
+    fn param_add<T: Add>(a: T, b: T) -> T::Output {
+        a + b // $ target=add
+    }
+
     pub fn f() {
         // Test for all overloadable operators on `i64`
 
@@ -1787,6 +1792,7 @@ mod overloadable_operators {
         let i64_mul = 17i64 * 18i64; // $ type=i64_mul:i64 target=mul
         let i64_div = 19i64 / 20i64; // $ type=i64_div:i64 target=div
         let i64_rem = 21i64 % 22i64; // $ type=i64_rem:i64 target=rem
+        let i64_param_add = param_add(1i64, 2i64); // $ target=param_add $ MISSING: type=i64_param_add:i64
 
         // Arithmetic assignment operators
         let mut i64_add_assign = 23i64;
@@ -2034,7 +2040,7 @@ mod impl_trait {
 mod indexers {
     use std::ops::Index;
 
-    #[derive(Debug)]
+    #[derive(Debug, Copy, Clone)]
     struct S;
 
     impl S {
@@ -2071,6 +2077,13 @@ mod indexers {
         let x = slice[0].foo(); // $ target=foo type=x:S target=index
     }
 
+    fn param_index<T: Index<usize>>(a: T, b: usize) -> T::Output
+    where
+        <T as Index<usize>>::Output: Sized + Copy,
+    {
+        a[b] // $ target=index
+    }
+
     pub fn f() {
         let mut vec = MyVec::new(); // $ type=vec:T.S target=new
         vec.push(S); // $ target=push
@@ -2079,6 +2092,8 @@ mod indexers {
         let xs: [S; 1] = [S];
         let x = xs[0].foo(); // $ target=foo type=x:S target=index
 
+        let y = param_index(vec, 0); // $ target=param_index $ MISSING: type=y:S
+
         analyze_slice(&xs); // $ target=analyze_slice
     }
 }