Rust: Rename type inference test inline expectation tag

Author: paldepind

rust/ql/lib/utils/test/internal/InlineExpectationsTestImpl.qll

@@ -4,6 +4,8 @@ private import codeql.util.test.InlineExpectationsTest
 
 module Impl implements InlineExpectationsTestSig {
   class ExpectationComment extends R::Comment {
+    ExpectationComment() { this.fromSource() }
+
     /** Gets the contents of the given comment, _without_ the preceding comment marker (`//`). */
     string getContents() { result = this.getCommentText() }
   }

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

@@ -30,73 +30,73 @@ impl<T> Deref for MySmartPointer<T> {
 fn explicit_monomorphic_dereference() {
     // Dereference with method call
     let a1 = MyIntPointer { value: 34i64 };
-    let _b1 = a1.deref(); // $ method=MyIntPointer::deref type=_b1:&T.i64
+    let _b1 = a1.deref(); // $ target=MyIntPointer::deref type=_b1:&T.i64
 
     // Dereference with overloaded dereference operator
     let a2 = MyIntPointer { value: 34i64 };
-    let _b2 = *a2; // $ method=MyIntPointer::deref type=_b2:i64
+    let _b2 = *a2; // $ target=MyIntPointer::deref type=_b2:i64
 
     // Call method on explicitly dereferenced value
     let a3 = MyIntPointer { value: 34i64 };
-    let _b3 = (*a3).is_positive(); // $ method=MyIntPointer::deref method=is_positive type=_b3:bool
+    let _b3 = (*a3).is_positive(); // $ target=MyIntPointer::deref target=is_positive type=_b3:bool
 }
 
 fn explicit_polymorphic_dereference() {
     // Explicit dereference with type parameter
     let c1 = MySmartPointer { value: 'a' };
-    let _d1 = c1.deref(); // $ method=MySmartPointer::deref type=_d1:&T.char
+    let _d1 = c1.deref(); // $ target=MySmartPointer::deref type=_d1:&T.char
 
     // Explicit dereference with type parameter
     let c2 = MySmartPointer { value: 'a' };
-    let _d2 = *c2; // $ method=MySmartPointer::deref type=_d2:char
+    let _d2 = *c2; // $ target=MySmartPointer::deref type=_d2:char
 
     // Call method on explicitly dereferenced value with type parameter
     let c3 = MySmartPointer { value: 34i64 };
-    let _d3 = (*c3).is_positive(); // $ method=MySmartPointer::deref method=is_positive type=_d3:bool
+    let _d3 = (*c3).is_positive(); // $ target=MySmartPointer::deref target=is_positive type=_d3:bool
 }
 
 fn explicit_ref_dereference() {
     // Explicit dereference with type parameter
     let e1 = &'a';
-    let _f1 = e1.deref(); // $ method=deref MISSING: type=_f1:&T.char
+    let _f1 = e1.deref(); // $ target=deref MISSING: type=_f1:&T.char
 
     // Explicit dereference with type parameter
     let e2 = &'a';
-    let _f2 = *e2; // $ method=deref type=_f2:char
+    let _f2 = *e2; // $ target=deref type=_f2:char
 
     // Call method on explicitly dereferenced value with type parameter
     let e3 = &34i64;
-    let _f3 = (*e3).is_positive(); // $ method=deref method=is_positive type=_f3:bool
+    let _f3 = (*e3).is_positive(); // $ target=deref target=is_positive type=_f3:bool
 }
 
 fn explicit_box_dereference() {
     // Explicit dereference with type parameter
-    let g1: Box<char> = Box::new('a'); // $ method=new
-    let _h1 = g1.deref(); // $ method=deref type=_h1:&T.char
+    let g1: Box<char> = Box::new('a'); // $ target=new
+    let _h1 = g1.deref(); // $ target=deref type=_h1:&T.char
 
     // Explicit dereference with type parameter
-    let g2: Box<char> = Box::new('a'); // $ method=new
-    let _h2 = *g2; // $ method=deref type=_h2:char
+    let g2: Box<char> = Box::new('a'); // $ target=new
+    let _h2 = *g2; // $ target=deref type=_h2:char
 
     // Call method on explicitly dereferenced value with type parameter
-    let g3: Box<i64> = Box::new(34i64); // $ method=new
-    let _h3 = (*g3).is_positive(); // $ method=deref method=is_positive type=_h3:bool
+    let g3: Box<i64> = Box::new(34i64); // $ target=new
+    let _h3 = (*g3).is_positive(); // $ target=deref target=is_positive type=_h3:bool
 }
 
 fn implicit_dereference() {
     // Call method on implicitly dereferenced value
     let x = MyIntPointer { value: 34i64 };
-    let _y = x.is_positive(); // $ MISSING: method=is_positive type=_y:bool
+    let _y = x.is_positive(); // $ MISSING: target=is_positive type=_y:bool
 
     // Call method on implicitly dereferenced value
     let x = MySmartPointer { value: 34i64 };
-    let _y = x.is_positive(); // $ MISSING: method=is_positive type=_y:bool
+    let _y = x.is_positive(); // $ MISSING: target=is_positive type=_y:bool
 }
 
 pub fn test() {
-    explicit_monomorphic_dereference(); // $ method=explicit_monomorphic_dereference
-    explicit_polymorphic_dereference(); // $ method=explicit_polymorphic_dereference
-    explicit_ref_dereference(); // $ method=explicit_ref_dereference
-    explicit_box_dereference(); // $ method=explicit_box_dereference
-    implicit_dereference(); // $ method=implicit_dereference
+    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
 }

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

@@ -9,6 +9,6 @@ trait T1<T>: T2<S<T>> {
 
 trait T2<T>: T1<S<T>> {
     fn bar(self) {
-        self.foo() // $ method=foo
+        self.foo() // $ target=foo
     }
 }

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

@@ -23,7 +23,7 @@ pub fn f() -> Option<()> {
         }
         None => (),
     };
-    let mesg = value.unwrap(); // $ method=unwrap
+    let mesg = value.unwrap(); // $ target=unwrap
     let mesg = mesg; // $ type=mesg:i32
     println!("{mesg}");
     let mesg = value?; // $ type=mesg:i32
@@ -108,21 +108,21 @@ pub fn f() -> Option<()> {
         _ => (),
     }
 
-    let opt1 = Some(Default::default()); // $ type=opt1:T.i32 method=default
+    let opt1 = Some(Default::default()); // $ type=opt1:T.i32 target=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
+    let opt2 = Some(Default::default()); // $ type=opt2:T.i32 target=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
+    let opt3 = Some(Default::default()); // $ type=opt3:T.i32 target=default
     #[rustfmt::skip]
     let _ = if let Option::<i32>::Some(x) = opt3
     {
@@ -240,7 +240,7 @@ pub fn identifier_patterns() {
     match mutable_value {
         mut x => {
             let mut_bound = x; // $ type=mut_bound:i32
-            x += 1;  // $ method=add_assign
+            x += 1; // $ target=add_assign
             println!("Mutable identifier: {}", mut_bound);
         }
     }
@@ -270,7 +270,7 @@ pub fn identifier_patterns() {
     match &mut ref_mut_val {
         ref mut x => {
             let ref_mut_bound = x; // $ type=ref_mut_bound:&T.&T.i32
-            **ref_mut_bound += 1; // $ method=deref method=add_assign
+            **ref_mut_bound += 1; // $ target=deref target=add_assign
             println!("Ref mut pattern");
         }
     }
@@ -698,7 +698,7 @@ pub fn complex_nested_patterns() {
             );
         }
         // Or pattern with tuple and wildcard
-        (Point { x, .. }, MyOption::None) | (Point { x: x@0, .. }, _) => {
+        (Point { x, .. }, MyOption::None) | (Point { x: x @ 0, .. }, _) => {
             let alt_complex_x = x; // $ type=alt_complex_x:i32
             println!("Alternative complex: x={:?}", alt_complex_x);
         }
@@ -766,15 +766,16 @@ pub fn patterns_in_function_parameters() {
 
     // Call the functions to use them
     let point = Point { x: 5, y: 10 };
-    let extracted = extract_point(point); // $ method=extract_point MISSING: type=extracted:?
+    let extracted = extract_point(point); // $ target=extract_point MISSING: type=extracted:?
 
     let color = Color(200, 100, 50);
-    let red = extract_color(color); // $ method=extract_color type=red:u8
+    let red = extract_color(color); // $ target=extract_color type=red:u8
 
     let tuple = (42i32, 3.14f64, true);
-    let tuple_extracted = extract_tuple(tuple); // $ method=extract_tuple MISSING: type=tuple_extracted:?
+    let tuple_extracted = extract_tuple(tuple); // $ target=extract_tuple MISSING: type=tuple_extracted:?
 }
 
+#[rustfmt::skip]
 pub fn patterns_in_control_flow() {
     // Patterns in for loops
     let points = vec![Point { x: 1, y: 2 }, Point { x: 3, y: 4 }];
@@ -793,15 +794,15 @@ pub fn patterns_in_control_flow() {
 
     // Patterns in while let
     let mut stack: Vec<i32> = vec![1i32, 2, 3];
-    while let Some(x) = stack.pop() { // $ method=pop
+    while let Some(x) = stack.pop() { // $ target=pop
         let while_let_x = x; // $ type=while_let_x:i32
         println!("Popped: {}", while_let_x);
     }
 
     // Patterns in match guards
     let value = 42i32;
     match value {
-        x if x > 0 => { // $ method=gt
+        x if x > 0 => { // $ target=gt
             let guard_x = x; // $ type=guard_x:i32
             println!("Positive: {}", guard_x);
         }
@@ -810,24 +811,23 @@ pub fn patterns_in_control_flow() {
 }
 
 pub fn test_all_patterns() {
-    f(); // $ method=f
-    literal_patterns(); // $ method=literal_patterns
-    identifier_patterns(); // $ method=identifier_patterns
-    wildcard_patterns(); // $ method=wildcard_patterns
-    range_patterns(); // $ method=range_patterns
-    reference_patterns(); // $ method=reference_patterns
-    record_patterns(); // $ method=record_patterns
-    tuple_struct_patterns(); // $ method=tuple_struct_patterns
-    tuple_patterns(); // $ method=tuple_patterns
-    parenthesized_patterns(); // $ method=parenthesized_patterns
-    slice_patterns(); // $ method=slice_patterns
-    path_patterns(); // $ method=path_patterns
-    or_patterns(); // $ method=or_patterns
-    rest_patterns(); // $ method=rest_patterns
-    macro_patterns(); // $ method=macro_patterns
-    complex_nested_patterns(); // $ method=complex_nested_patterns
-    patterns_in_let_statements(); // $ method=patterns_in_let_statements
-    patterns_in_function_parameters(); // $ method=patterns_in_function_parameters
-    patterns_in_control_flow(); // $ method=patterns_in_control_flow
+    f(); // $ target=f
+    literal_patterns(); // $ target=literal_patterns
+    identifier_patterns(); // $ target=identifier_patterns
+    wildcard_patterns(); // $ target=wildcard_patterns
+    range_patterns(); // $ target=range_patterns
+    reference_patterns(); // $ target=reference_patterns
+    record_patterns(); // $ target=record_patterns
+    tuple_struct_patterns(); // $ target=tuple_struct_patterns
+    tuple_patterns(); // $ target=tuple_patterns
+    parenthesized_patterns(); // $ target=parenthesized_patterns
+    slice_patterns(); // $ target=slice_patterns
+    path_patterns(); // $ target=path_patterns
+    or_patterns(); // $ target=or_patterns
+    rest_patterns(); // $ target=rest_patterns
+    macro_patterns(); // $ target=macro_patterns
+    complex_nested_patterns(); // $ target=complex_nested_patterns
+    patterns_in_let_statements(); // $ target=patterns_in_let_statements
+    patterns_in_function_parameters(); // $ target=patterns_in_function_parameters
+    patterns_in_control_flow(); // $ target=patterns_in_control_flow
 }
-

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

@@ -12,7 +12,7 @@ query predicate inferType(AstNode n, TypePath path, Type t) {
 }
 
 module ResolveTest implements TestSig {
-  string getARelevantTag() { result = ["method", "fieldof"] }
+  string getARelevantTag() { result = ["target", "fieldof"] }
 
   private predicate functionHasValue(Function f, string value) {
     f.getAPrecedingComment().getCommentText() = value and
@@ -34,7 +34,7 @@ module ResolveTest implements TestSig {
       functionHasValue(target, value) and
       // `isFromMacroExpansion` does not always work
       not target.(Function).getName().getText() = ["panic_fmt", "_print", "format", "must_use"] and
-      tag = "method"
+      tag = "target"
       or
       target = resolveStructFieldExpr(source) and
       any(Struct s | s.getStructField(_) = target).getName().getText() = value and