Rust: Add type inference tests

Author: hvitved

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

@@ -1,5 +1,7 @@
 multipleCallTargets
-| dereference.rs:61:15:61:24 | e1.deref() |
+| 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:2308:13:2308:31 | ...::from(...) |
 | main.rs:2309:13:2309:31 | ...::from(...) |
 | main.rs:2310:13:2310: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

@@ -2558,25 +2558,23 @@ pub mod exec {
 pub mod path_buf {
     // a highly simplified model of `PathBuf::canonicalize`
 
-    pub struct Path {
-    }
+    pub struct Path {}
 
     impl Path {
         pub const fn new() -> Path {
-            Path { }
+            Path {}
         }
 
         pub fn canonicalize(&self) -> Result<PathBuf, ()> {
             Ok(PathBuf::new()) // $ target=new
         }
     }
 
-    pub struct PathBuf {
-    }
+    pub struct PathBuf {}
 
     impl PathBuf {
         pub const fn new() -> PathBuf {
-            PathBuf { }
+            PathBuf {}
         }
     }
 
@@ -2587,7 +2585,7 @@ pub mod path_buf {
         #[inline]
         fn deref(&self) -> &Path {
             // (very much not a real implementation)
-            static path : Path = Path::new(); // $ target=new
+            static path: Path = Path::new(); // $ target=new
             &path
         }
     }