Merge pull request #20029 from github/aibaars/more-pattern-tests

Rust: add more type inference tests for patterns and a simple one for a closure call

Author: aibaars

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

@@ -1,7 +1,7 @@
+#![feature(box_patterns)]
 mod field_access {
     #[derive(Debug)]
     struct S;
-
     #[derive(Debug)]
     struct MyThing {
         a: S,
@@ -2351,139 +2351,39 @@ mod tuples {
     }
 }
 
-pub mod pattern_matching {
-    struct MyRecordStruct<T1, T2> {
-        value1: T1,
-        value2: T2,
-    }
-
-    struct MyTupleStruct<T1, T2>(T1, T2);
-
-    enum MyEnum<T1, T2> {
-        Variant1 { value1: T1, value2: T2 },
-        Variant2(T2, T1),
-    }
+pub mod pattern_matching;
+pub mod pattern_matching_experimental {
+    pub fn box_patterns() {
+        let boxed_value = Box::new(100i32); // $ method=new
 
-    pub fn f() -> Option<()> {
-        let value = Some(42);
-        if let Some(mesg) = value {
-            let mesg = mesg; // $ type=mesg:i32
-            println!("{mesg}");
-        }
-        match value {
-            Some(mesg) => {
-                let mesg = mesg; // $ type=mesg:i32
-                println!("{mesg}");
+        // BoxPat - Box patterns (requires feature flag)
+        match boxed_value {
+            box 100 => {
+                println!("Boxed 100");
             }
-            None => (),
-        };
-        let mesg = value.unwrap(); // $ method=unwrap
-        let mesg = mesg; // $ type=mesg:i32
-        println!("{mesg}");
-        let mesg = value?; // $ type=mesg:i32
-        println!("{mesg}");
-
-        let value2 = &Some(42);
-        if let &Some(mesg) = value2 {
-            let mesg = mesg; // $ type=mesg:i32
-            println!("{mesg}");
-        }
-
-        let value3 = 42;
-        if let ref mesg = value3 {
-            let mesg = mesg; // $ type=mesg:&T.i32
-            println!("{mesg}");
-        }
-
-        let value4 = Some(42);
-        if let Some(ref mesg) = value4 {
-            let mesg = mesg; // $ type=mesg:&T.i32
-            println!("{mesg}");
-        }
-
-        let ref value5 = 42;
-        let x = value5; // $ type=x:&T.i32
-
-        let my_record_struct = MyRecordStruct {
-            value1: 42,
-            value2: false,
-        };
-        if let MyRecordStruct { value1, value2 } = my_record_struct {
-            let x = value1; // $ type=x:i32
-            let y = value2; // $ type=y:bool
-            ();
-        }
-
-        let my_tuple_struct = MyTupleStruct(42, false);
-        if let MyTupleStruct(value1, value2) = my_tuple_struct {
-            let x = value1; // $ type=x:i32
-            let y = value2; // $ type=y:bool
-            ();
-        }
-
-        let my_enum1 = MyEnum::Variant1 {
-            value1: 42,
-            value2: false,
-        };
-        match my_enum1 {
-            MyEnum::Variant1 { value1, value2 } => {
-                let x = value1; // $ type=x:i32
-                let y = value2; // $ type=y:bool
-                ();
-            }
-            MyEnum::Variant2(value1, value2) => {
-                let x = value1; // $ type=x:bool
-                let y = value2; // $ type=y:i32
-                ();
+            box x => {
+                let unboxed = x; // $ MISSING: type=unboxed:i32
+                println!("Boxed value: {}", unboxed);
             }
         }
 
-        let my_nested_enum = MyEnum::Variant2(
-            false,
-            MyRecordStruct {
-                value1: 42,
-                value2: "string",
-            },
-        );
-
-        match my_nested_enum {
-            MyEnum::Variant2(
-                value1,
-                MyRecordStruct {
-                    value1: x,
-                    value2: y,
-                },
-            ) => {
-                let a = value1; // $ type=a:bool
-                let b = x; // $ type=b:i32
-                let c = y; // $ type=c:&T.str
-                ();
+        // Nested box pattern
+        let nested_box = Box::new(Box::new(42i32)); // $ method=new
+        match nested_box {
+            box box x => {
+                let nested_unboxed = x; // $ MISSING: type=nested_unboxed:i32
+                println!("Nested boxed: {}", nested_unboxed);
             }
-            _ => (),
         }
+    }
+}
 
-        let opt1 = Some(Default::default()); // $ type=opt1:T.i32 method=default
-        #[rustfmt::skip]
-        let _ = if let Some::<i32>(x) = opt1
-        {
-            x; // $ type=x:i32
-        };
-
-        let opt2 = Some(Default::default()); // $ type=opt2:T.i32 method=default
-        #[rustfmt::skip]
-        let _ = if let Option::Some::<i32>(x) = opt2
-        {
-            x; // $ type=x:i32
-        };
-
-        let opt3 = Some(Default::default()); // $ type=opt3:T.i32 method=default
-        #[rustfmt::skip]
-        let _ = if let Option::<i32>::Some(x) = opt3
-        {
-            x; // $ type=x:i32
-        };
-
-        None
+mod closures {
+    pub fn f() {
+        Some(1).map(|x| {
+            let x = x; // $ MISSING: type=x:i32
+            println!("{x}");
+        });  // $ method=map
     }
 }
 
@@ -2515,5 +2415,7 @@ fn main() {
     method_determined_by_argument_type::f(); // $ method=f
     tuples::f(); // $ method=f
     dereference::test(); // $ method=test
-    pattern_matching::f(); // $ method=f
+    pattern_matching::test_all_patterns(); // $ method=test_all_patterns
+    pattern_matching_experimental::box_patterns(); // $ method=box_patterns
+    closures::f() // $ method=f
 }

rust/ql/test/library-tests/type-inference/options.yml

@@ -0,0 +1 @@
+qltest_use_nightly: true