Rust: Add tests for chained let expressions

Author: hvitved

rust/ql/test/library-tests/dataflow/local/CONSISTENCY/PathResolutionConsistency.expected

@@ -1,2 +1,2 @@
 multipleCallTargets
-| main.rs:445:18:445:24 | n.len() |
+| main.rs:471:18:471:24 | n.len() |

rust/ql/test/library-tests/dataflow/local/DataFlowStep.expected

@@ -1,3 +1,4 @@
+#![feature(let_chains)]
 // Tests for intraprocedural data flow.
 
 fn source(i: i64) -> i64 {
@@ -21,6 +22,19 @@ fn direct() {
 fn variable_usage() {
     let s = source(2);
     sink(s); // $ hasValueFlow=2
+
+    if let x = s {
+        sink(x); // $ MISSING: hasValueFlow=2
+    };
+
+    if let x = s
+        && {
+            sink(x); // $ MISSING: hasValueFlow=2
+            true
+        }
+    {
+        sink(x); // $ MISSING: hasValueFlow=2
+    };
 }
 
 fn if_expression(cond: bool) {
@@ -236,6 +250,18 @@ fn option_pattern_match_unqualified() {
     }
 }
 
+fn option_chained_let() {
+    let s1 = Some(source(45));
+    if let Some(n) = s1
+        && {
+            sink(n); // $ MISSING: hasValueFlow=45
+            true
+        }
+    {
+        sink(n); // $ MISSING: hasValueFlow=45
+    }
+}
+
 fn option_unwrap() {
     let s1 = Some(source(19));
     sink(s1.unwrap()); // $ hasValueFlow=19
@@ -558,6 +584,7 @@ fn main() {
     struct_nested_match();
     option_pattern_match_qualified();
     option_pattern_match_unqualified();
+    option_chained_let();
     option_unwrap();
     option_unwrap_or();
     option_questionmark();

rust/ql/test/library-tests/dataflow/local/inline-flow.expected

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

rust/ql/test/library-tests/dataflow/local/main.rs

@@ -1,3 +1,3 @@
 multipleCallTargets
-| main.rs:87:19:87:40 | ...::from(...) |
-| main.rs:106:19:106:40 | ...::from(...) |
+| main.rs:88:19:88:40 | ...::from(...) |
+| main.rs:107:19:107:40 | ...::from(...) |

rust/ql/test/library-tests/dataflow/local/options.yml

@@ -1,3 +1,4 @@
+#![feature(let_chains)]
 use std::ops::AddAssign;
 
 fn print_str(s: &str) // s
@@ -269,6 +270,37 @@ fn match_pattern9() {
     }
 }
 
+#[rustfmt::skip]
+fn match_pattern10() {
+    let o = Some(42); // o
+    if let Some(x)
+    = o // $ read_access=o
+    &&
+    x > 0 // $ MISSING: read_access=x
+    {    
+        print_i64(x); // $ MISSING: read_access=x
+    } else {
+        print_str("No value");
+    }
+}
+
+#[rustfmt::skip]
+fn match_pattern11() {
+    let x = Some(42); // x1
+    if let Some(x) // x2
+    = x // $ read_access=x1
+    &&
+    let Some(x) // x3
+    = Some(x) // $ MISSING: read_access=x2 $ SPURIOUS: read_access=x1
+    &&
+    x > 0 // $ MISSING: read_access=x3 $ SPURIOUS: read_access=x1
+    {    
+        print_i64(x); // $ MISSING: read_access=x3 $ SPURIOUS: read_access=x1
+    } else {
+        print_str("No value");
+    }
+}
+
 fn param_pattern1(
     a8: &str, // a8
     (
@@ -417,6 +449,7 @@ fn mutate_arg() {
     let y = // y
         mutate_param(&mut x); // $ access=x
     *y = 10; // $ read_access=y
+
     // prints 10, not 4
     print_i64(x); // $ read_access=x
 
@@ -428,6 +461,7 @@ fn mutate_arg() {
         w,      // $ read_access=w
     );
     **w = 11; // $ read_access=w
+
     // prints 11, not 8
     print_i64(z); // $ read_access=z
 }
@@ -442,6 +476,7 @@ fn alias() {
 
 fn capture_immut() {
     let x = 100; // x
+
     // Captures immutable value by immutable reference
     let cap = || {
         print_i64(x); // $ read_access=x
@@ -452,6 +487,7 @@ fn capture_immut() {
 
 fn capture_mut() {
     let mut x = 1; // x
+
     // Captures mutable value by immutable reference
     let closure1 = || {
         print_i64(x); // $ read_access=x
@@ -460,6 +496,7 @@ fn capture_mut() {
     print_i64(x); // $ read_access=x
 
     let mut y = 2; // y
+
     // Captures mutable value by mutable reference
     let mut closure2 = || {
         y = 3; // $ write_access=y
@@ -468,6 +505,7 @@ fn capture_mut() {
     print_i64(y); // $ read_access=y
 
     let mut z = 2; // z
+
     // Captures mutable value by mutable reference and calls mutating method
     let mut closure3 = || {
         z.add_assign(1); // $ read_access=z
@@ -586,6 +624,7 @@ impl MyStruct {
 fn ref_methodcall_receiver() {
     let mut a = MyStruct { val: 1 }; // a
     a.bar(); // $ read_access=a
+
     // prints 3, not 1
     print_i64(a.val); // $ read_access=a
 }
@@ -609,6 +648,7 @@ fn macro_invocation() {
         let_in_macro!(37); // $ read_access=var_in_macro
     print_i64(var_from_macro); // $ read_access=var_from_macro1
     let var_in_macro = 33; // var_in_macro1
+
     // Our analysis does not currently respect the hygiene rules of Rust macros
     // (https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html), because
     // all we have access to is the expanded AST
@@ -653,6 +693,8 @@ fn main() {
     match_pattern7();
     match_pattern8();
     match_pattern9();
+    match_pattern10();
+    match_pattern11();
     param_pattern1("a", ("b", "c"));
     param_pattern2(Either::Left(45));
     destruct_assignment();

rust/ql/test/library-tests/variables/CONSISTENCY/PathResolutionConsistency.expected

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