Rust: Add type inference tests for type aliases

Author: paldepind

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

@@ -540,6 +540,17 @@ mod type_aliases {
         PairBoth(Fst, Snd),
     }
 
+    impl<Fst, Snd> PairOption<Fst, Snd> {
+        fn unwrapSnd(self) -> Snd {
+            match self {
+                PairOption::PairNone() => panic!("PairNone has no second element"),
+                PairOption::PairFst(_) => panic!("PairFst has no second element"),
+                PairOption::PairSnd(snd) => snd,
+                PairOption::PairBoth(_, snd) => snd,
+            }
+        }
+    }
+
     #[derive(Debug)]
     struct S1;
 
@@ -553,24 +564,37 @@ mod type_aliases {
     type MyPair = PairOption<S1, S2>;
 
     // Generic type alias that partially applies the generic type
-    type AnotherPair<Thr> = PairOption<S2, Thr>;
+    type AnotherPair<A3> = PairOption<S2, A3>;
+
+    // Alias to another alias
+    type AliasToAlias<A4> = AnotherPair<A4>;
+
+    // Alias that appears nested withing another alias
+    type NestedAlias<A5> = AnotherPair<AliasToAlias<A5>>;
+
+    fn g(t: NestedAlias<S3>) {
+        let x = t.unwrapSnd().unwrapSnd(); // $ method=unwrapSnd MISSING: type=x:S3
+        println!("{:?}", x);
+    }
 
     pub fn f() {
         // Type can be inferred from the constructor
         let p1: MyPair = PairOption::PairBoth(S1, S2);
         println!("{:?}", p1);
 
         // Type can be only inferred from the type alias
-        let p2: MyPair = PairOption::PairNone(); // types for `Fst` and `Snd` missing
+        let p2: MyPair = PairOption::PairNone(); // $ MISSING: type=p2:Fst.S1 MISSING: type=p2:Snd.S2
         println!("{:?}", p2);
 
         // First type from alias, second from constructor
-        let p3: AnotherPair<_> = PairOption::PairSnd(S3); // type for `Fst` missing
+        let p3: AnotherPair<_> = PairOption::PairSnd(S3); // $ MISSING: type=p3:Fst.S2
         println!("{:?}", p3);
 
         // First type from alias definition, second from argument to alias
-        let p3: AnotherPair<S3> = PairOption::PairNone(); // type for `Snd` missing, spurious `S3` for `Fst`
+        let p3: AnotherPair<S3> = PairOption::PairNone(); // $ SPURIOUS: type=p3:Fst.S3 MISSING: type=p3:Snd.S3
         println!("{:?}", p3);
+
+        g(PairOption::PairSnd(PairOption::PairSnd(S3)));
     }
 }