Use query ID

Author: hvitved

rust/ql/test/query-tests/unusedentities/UnreachableCode.ext.yml

@@ -3,10 +3,10 @@
 // --- locals ---
 
 fn locals_1() {
-    let a = 1; // $ Alert[value that is never used]
+    let a = 1; // $ Alert[rust/unused-value]
     let b = 1;
     let c = 1;
-    let d = String::from("a"); // $ Alert[value that is never used]
+    let d = String::from("a"); // $ Alert[rust/unused-value]
     let e = String::from("b");
     let f = 1;
     let _ = 1; // (deliberately unused)
@@ -22,7 +22,7 @@ fn locals_1() {
 }
 
 fn locals_2() {
-    let a: i32; // $ Alert[Variable is not used]
+    let a: i32; // $ Alert[rust/unused-variable]
     let b: i32;
     let mut c: i32;
     let mut d: i32;
@@ -32,22 +32,22 @@ fn locals_2() {
     let h: i32;
     let i: i32;
 
-    b = 1; // $ Alert[value that is never used]
+    b = 1; // $ Alert[rust/unused-value]
 
-    c = 1; // $ Alert[value that is never used]
+    c = 1; // $ Alert[rust/unused-value]
     c = 2;
     println!("use {}", c);
-    c = 3; // $ Alert[value that is never used]
+    c = 3; // $ Alert[rust/unused-value]
 
     d = 1;
     if cond() {
-        d = 2; // $ Alert[value that is never used]
+        d = 2; // $ Alert[rust/unused-value]
         d = 3;
     } else {
     }
     println!("use {}", d);
 
-    e = 1; // $ Alert[value that is never used]
+    e = 1; // $ Alert[rust/unused-value]
     if cond() {
         e = 2;
     } else {
@@ -58,11 +58,11 @@ fn locals_2() {
     f = 1;
     f += 1;
     println!("use {}", f);
-    f += 1; // $ Alert[value that is never used]
+    f += 1; // $ Alert[rust/unused-value]
     f = 1;
-    f += 1; // $ Alert[value that is never used]
+    f += 1; // $ Alert[rust/unused-value]
 
-    g = if cond() { 1 } else { 2 }; // $ Alert[value that is never used]
+    g = if cond() { 1 } else { 2 }; // $ Alert[rust/unused-value]
     h = if cond() { 3 } else { 4 };
     i = if cond() { h } else { 5 };
     println!("use {}", i);
@@ -84,10 +84,10 @@ impl MyStruct {
 }
 
 fn structs() {
-    let a = MyStruct { val: 1 }; // $ Alert[value that is never used]
+    let a = MyStruct { val: 1 }; // $ Alert[rust/unused-value]
     let b = MyStruct { val: 2 };
     let c = MyStruct { val: 3 };
-    let mut d: MyStruct; // $ Alert[Variable is not used]
+    let mut d: MyStruct; // $ Alert[rust/unused-variable]
     let mut e: MyStruct;
     let mut f: MyStruct;
 
@@ -98,14 +98,14 @@ fn structs() {
     e.val = 5;
     println!("lets use {}", e.my_get());
 
-    f = MyStruct { val: 6 }; // $ MISSING: Alert[value that is never used]
-    f.val = 7; // $ MISSING: Alert[value that is never used]
+    f = MyStruct { val: 6 }; // $ MISSING: Alert[rust/unused-value]
+    f.val = 7; // $ MISSING: Alert[rust/unused-value]
 }
 
 // --- arrays ---
 
 fn arrays() {
-    let is = [1, 2, 3]; // $ Alert[value that is never used]
+    let is = [1, 2, 3]; // $ Alert[rust/unused-value]
     let js = [1, 2, 3];
     let ks = [1, 2, 3];
 
@@ -119,24 +119,24 @@ fn arrays() {
 // --- constants and statics ---
 
 const CON1: i32 = 1;
-const CON2: i32 = 2; // $ MISSING: Alert[value that is never used]
+const CON2: i32 = 2; // $ MISSING: Alert[rust/unused-value]
 static mut STAT1: i32 = 1;
-static mut STAT2: i32 = 2; // $ MISSING: Alert[value that is never used]
+static mut STAT2: i32 = 2; // $ MISSING: Alert[rust/unused-value]
 
 fn statics() {
     static mut STAT3: i32 = 0;
-    static mut STAT4: i32 = 0; // $ MISSING: Alert[value that is never used]
+    static mut STAT4: i32 = 0; // $ MISSING: Alert[rust/unused-value]
 
     unsafe {
-        let total = CON1 + STAT1 + STAT3; // $ Alert[value that is never used]
+        let total = CON1 + STAT1 + STAT3; // $ Alert[rust/unused-value]
     }
 }
 
 // --- parameters ---
 
 fn parameters(
     x: i32,
-    y: i32,  // $ Alert[Variable is not used]
+    y: i32,  // $ Alert[rust/unused-variable]
     _z: i32, // (`_` is asking the compiler, and by extension us, to not warn that this is unused)
 ) -> i32 {
     return x;
@@ -163,7 +163,7 @@ fn loops() {
         e += x;
     }
 
-    for x in 1..10 { // $ Alert[Variable is not used]
+    for x in 1..10 { // $ Alert[rust/unused-variable]
     }
 
     for _ in 1..10 {}
@@ -191,7 +191,7 @@ fn loops() {
     }
 
     for x in 1..10 {
-        _ = format!("x is {x}"); // $ SPURIOUS: Alert[value that is never used]
+        _ = format!("x is {x}"); // $ SPURIOUS: Alert[rust/unused-value]
     }
 
     for x in 1..10 {
@@ -203,11 +203,11 @@ fn loops() {
     }
 
     for x in 1..10 {
-        assert_eq!(x, 1); // $ SPURIOUS: Alert[value that is never used]
+        assert_eq!(x, 1); // $ SPURIOUS: Alert[rust/unused-value]
     }
 
     for x in 1..10 {
-        assert_eq!(id(x), id(1)); // $ SPURIOUS: Alert[value that is never used]
+        assert_eq!(id(x), id(1)); // $ SPURIOUS: Alert[rust/unused-value]
     }
 }
 
@@ -233,15 +233,15 @@ struct MyPoint {
 fn if_lets_matches() {
     let mut total: i64 = 0;
 
-    if let Some(a) = Some(10) { // $ Alert[Variable is not used]
+    if let Some(a) = Some(10) { // $ Alert[rust/unused-variable]
     }
 
     if let Some(b) = Some(20) {
         total += b;
     }
 
     let mut next = Some(30);
-    while let Some(val) = // $ Alert[Variable is not used]
+    while let Some(val) = // $ Alert[rust/unused-variable]
         next
     {
         next = None;
@@ -255,37 +255,37 @@ fn if_lets_matches() {
 
     let c = Some(60);
     match c {
-        Some(val) => { // $ Alert[Variable is not used]
+        Some(val) => { // $ Alert[rust/unused-variable]
         }
         None => {}
     }
 
     let d = Some(70);
     match d {
         Some(val) => {
-            total += val; // $ Alert[value that is never used]
+            total += val; // $ Alert[rust/unused-value]
         }
         None => {}
     }
 
     let e = Option::Some(80);
     match e {
-        Option::Some(val) => { // $ Alert[Variable is not used]
+        Option::Some(val) => { // $ Alert[rust/unused-variable]
         }
         Option::None => {}
     }
 
     let f = MyOption::Some(90);
     match f {
-        MyOption::Some(val) => { // $ Alert[Variable is not used]
+        MyOption::Some(val) => { // $ Alert[rust/unused-variable]
         }
         MyOption::None => {}
     }
 
     let g: Result<i64, i64> = Ok(100);
     match g {
         Ok(_) => {}
-        Err(num) => {} // $ Alert[Variable is not used]
+        Err(num) => {} // $ Alert[rust/unused-variable]
     }
 
     let h = YesOrNo::Yes;
@@ -300,7 +300,7 @@ fn if_lets_matches() {
         No => {}
     }
 
-    if let j = Yes { // $ Alert[Variable is not used]
+    if let j = Yes { // $ Alert[rust/unused-variable]
     }
 
     if let k = Yes {
@@ -320,18 +320,18 @@ fn if_lets_matches() {
     let p1 = MyPoint { x: 1, y: 2 };
     match p1 {
         MyPoint { x: 0, y: 0 } => {}
-        MyPoint { x: 1, y } => { // $ Alert[Variable is not used]
+        MyPoint { x: 1, y } => { // $ Alert[rust/unused-variable]
         }
         MyPoint { x: 2, y: _ } => {}
-        MyPoint { x: 3, y: a } => { // $ Alert[Variable is not used]
+        MyPoint { x: 3, y: a } => { // $ Alert[rust/unused-variable]
         }
         MyPoint { x: 4, .. } => {}
-        p => { // $ Alert[Variable is not used]
+        p => { // $ Alert[rust/unused-variable]
         }
     }
 
     let duration1 = std::time::Duration::new(10, 0); // ten seconds
-    assert_eq!(duration1.as_secs(), 10); // $ SPURIOUS: Alert[value that is never used]
+    assert_eq!(duration1.as_secs(), 10); // $ SPURIOUS: Alert[rust/unused-value]
 
     let duration2: Result<std::time::Duration, String> = Ok(std::time::Duration::new(10, 0));
     match duration2 {
@@ -344,28 +344,28 @@ fn if_lets_matches() {
     }
 
     let (left,
-        right) = // $ MISSING: Alert[value that is never used] $ SPURIOUS: Alert[Variable is not used]
+        right) = // $ MISSING: Alert[rust/unused-value] $ SPURIOUS: Alert[rust/unused-variable]
         (1, 2);
     _ = left;
 
     let pair = (1, 2);
     let (left2,
-        right2) = // $ MISSING: Alert[value that is never used] $ SPURIOUS: Alert[Variable is not used]
+        right2) = // $ MISSING: Alert[rust/unused-value] $ SPURIOUS: Alert[rust/unused-variable]
         pair;
     _ = left2;
 }
 
 fn shadowing() -> i32 {
-    let x = 1; // $ Alert[value that is never used]
-    let mut y: i32; // $ Alert[Variable is not used]
+    let x = 1; // $ Alert[rust/unused-value]
+    let mut y: i32; // $ Alert[rust/unused-variable]
 
     {
         let x = 2;
         let mut y: i32;
 
         {
-            let x = 3; // $ Alert[value that is never used]
-            let mut y: i32; // $ Alert[Variable is not used]
+            let x = 3; // $ Alert[rust/unused-value]
+            let mut y: i32; // $ Alert[rust/unused-variable]
         }
 
         y = x;
@@ -410,12 +410,12 @@ fn folds_and_closures() {
     _ = a3.fold(0, |acc, val| acc + val);
 
     let a4 = 1..10;
-    _ = a4.fold(0, |acc, val| acc); // $ Alert[Variable is not used]
+    _ = a4.fold(0, |acc, val| acc); // $ Alert[rust/unused-variable]
 
     let a5 = 1..10;
-    _ = a5.fold(0, |acc, val| val); // $ Alert[Variable is not used]
+    _ = a5.fold(0, |acc, val| val); // $ Alert[rust/unused-variable]
 
-    let i6 = 1; // $ SPURIOUS: Alert[value that is never used]
+    let i6 = 1; // $ SPURIOUS: Alert[rust/unused-value]
     let a6 = 1..10;
     _ = a6.fold(0, |acc, val| acc + val + i6);
 }
@@ -434,7 +434,7 @@ impl Incrementable for MyValue {
     fn increment(
         &mut self,
         times: i32,
-        unused: i32, // $ Alert[Variable is not used]
+        unused: i32, // $ Alert[rust/unused-variable]
     ) {
         self.value += times;
     }

rust/ql/test/query-tests/unusedentities/UnusedValue.ext.yml

@@ -21,14 +21,14 @@ impl<T> MySettable<T> for MyContainer<T> {
 impl<T> MyGettable<T> for MyContainer<T> {
     fn get(
         &self,
-        val: T, // $ SPURIOUS: Alert[value that is never used] $ MISSING: Alert[Variable is not used]
+        val: T, // $ SPURIOUS: Alert[rust/unused-value] $ MISSING: Alert[rust/unused-variable]
     ) -> &T {
         return &(self.val);
     }
 }
 
 fn generics() {
-    let mut a = MyContainer { val: 1 }; // $ MISSING: Alert[value that is never used]
+    let mut a = MyContainer { val: 1 }; // $ MISSING: Alert[rust/unused-value]
     let b = MyContainer { val: 2 };
 
     a.set(*b.get(3));
@@ -40,13 +40,13 @@ fn pointers() {
     let a = 1;
     let a_ptr1 = &a;
     let a_ptr2 = &a;
-    let a_ptr3 = &a; // $ MISSING: Alert[value that is never used]
-    let a_ptr4 = &a; // $ Alert[value that is never used]
+    let a_ptr3 = &a; // $ MISSING: Alert[rust/unused-value]
+    let a_ptr4 = &a; // $ Alert[rust/unused-value]
     println!("{}", *a_ptr1);
     println!("{}", a_ptr2);
     println!("{}", &a_ptr3);
 
-    let b = 2; // $ MISSING: Alert[value that is never used]
+    let b = 2; // $ MISSING: Alert[rust/unused-value]
     let b_ptr = &b;
     println!("{}", b_ptr);
 
@@ -56,26 +56,26 @@ fn pointers() {
     println!("{}", **c_ptr_ptr);
 
     let d = 4;
-    let d_ptr = &d; // $ Alert[value that is never used]
+    let d_ptr = &d; // $ Alert[rust/unused-value]
     let d_ptr_ptr = &&d;
     println!("{}", **d_ptr_ptr);
 
-    let e = 5; // $ MISSING: Alert[value that is never used]
+    let e = 5; // $ MISSING: Alert[rust/unused-value]
     let f = 6;
-    let mut f_ptr = &e; // $ Alert[value that is never used]
+    let mut f_ptr = &e; // $ Alert[rust/unused-value]
     f_ptr = &f;
     println!("{}", *f_ptr);
 
-    let mut g = 7; // $ MISSING: Alert[value that is never used]
+    let mut g = 7; // $ MISSING: Alert[rust/unused-value]
     let g_ptr = &mut g;
-    *g_ptr = 77; // $ MISSING: Alert[value that is never used]
+    *g_ptr = 77; // $ MISSING: Alert[rust/unused-value]
 
-    let mut h = 8; // $ MISSING: Alert[value that is never used]
+    let mut h = 8; // $ MISSING: Alert[rust/unused-value]
     let h_ptr = &mut h;
     *h_ptr = 88;
     println!("{}", h);
 
-    let mut i = 9; // $ MISSING: Alert[value that is never used]
+    let mut i = 9; // $ MISSING: Alert[rust/unused-value]
     let i_ptr = &mut i;
     *i_ptr = 99;
     let i_ptr2 = &mut i;