Rust: Add type inference test

Author: hvitved

ruby/ql/lib/codeql/ruby/ast/Call.qll

@@ -1,6 +1,7 @@
 private import codeql.ruby.AST
 private import internal.AST
 private import internal.Call
+private import internal.Literal
 private import internal.TreeSitter
 private import codeql.ruby.dataflow.internal.DataFlowDispatch
 private import codeql.ruby.dataflow.internal.DataFlowImplCommon
@@ -41,7 +42,7 @@ class Call extends Expr instanceof CallImpl {
   final Expr getKeywordArgument(string keyword) {
     exists(Pair p |
       p = this.getAnArgument() and
-      p.getKey().getConstantValue().isSymbol(keyword) and
+      keyword = p.getKey().(SymbolLiteral).(StringlikeLiteralImpl).getStringValue() and
       result = p.getValue()
     )
   }

ruby/ql/lib/codeql/ruby/ast/Expr.qll

@@ -2,6 +2,7 @@ private import codeql.ruby.AST
 private import codeql.ruby.CFG
 private import internal.AST
 private import internal.Constant
+private import internal.Literal
 private import internal.Expr
 private import internal.TreeSitter
 
@@ -427,11 +428,11 @@ class StringConcatenation extends Expr, TStringConcatenation {
    */
   final string getConcatenatedValueText() {
     forall(StringLiteral c | c = this.getString(_) |
-      exists(c.getConstantValue().getStringlikeValue())
+      exists(c.(StringlikeLiteralImpl).getStringValue())
     ) and
     result =
       concat(string valueText, int i |
-        valueText = this.getString(i).getConstantValue().getStringlikeValue()
+        valueText = this.getString(i).(StringlikeLiteralImpl).getStringValue()
       |
         valueText order by i
       )

ruby/ql/lib/codeql/ruby/ast/Pattern.qll

@@ -4,6 +4,7 @@ private import internal.Pattern
 private import internal.TreeSitter
 private import internal.Variable
 private import internal.Parameter
+private import internal.Literal
 
 private class TPatternNode =
   TArrayPattern or TFindPattern or THashPattern or TAlternativePattern or TAsPattern or
@@ -205,7 +206,7 @@ class HashPattern extends CasePattern, THashPattern {
   /** Gets the value for a given key name. */
   CasePattern getValueByKey(string key) {
     exists(int i |
-      this.getKey(i).getConstantValue().isStringlikeValue(key) and result = this.getValue(i)
+      key = this.getKey(i).(StringlikeLiteralImpl).getStringValue() and result = this.getValue(i)
     )
   }
 

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

@@ -2006,7 +2006,11 @@ mod method_determined_by_argument_type {
 
         // MyAdd<bool>::my_add
         fn my_add(self, value: bool) -> Self {
-            if value { 1 } else { 0 }
+            if value {
+                1
+            } else {
+                0
+            }
         }
     }
 
@@ -2042,6 +2046,52 @@ mod method_determined_by_argument_type {
         }
     }
 
+    trait MyFrom<T> {
+        // MyFrom::my_from
+        fn my_from(value: T) -> Self;
+    }
+
+    impl MyFrom<i64> for i64 {
+        // MyFrom<i64>::my_from
+        fn my_from(value: i64) -> Self {
+            value
+        }
+    }
+
+    impl MyFrom<bool> for i64 {
+        // MyFrom<bool>::my_from
+        fn my_from(value: bool) -> Self {
+            if value {
+                1
+            } else {
+                0
+            }
+        }
+    }
+
+    trait MyFrom2<T> {
+        // MyFrom2::my_from2
+        fn my_from2(value: T, x: Self) -> ();
+    }
+
+    impl MyFrom2<i64> for i64 {
+        // MyFrom2<i64>::my_from2
+        fn my_from2(value: i64, _: Self) -> () {
+            value;
+        }
+    }
+
+    impl MyFrom2<bool> for i64 {
+        // MyFrom2<bool>::my_from2
+        fn my_from2(value: bool, _: Self) -> () {
+            if value {
+                1
+            } else {
+                0
+            };
+        }
+    }
+
     pub fn f() {
         let x: i64 = 73;
         x.my_add(5i64); // $ method=MyAdd<i64>::my_add
@@ -2051,6 +2101,13 @@ mod method_determined_by_argument_type {
         S(1i64).my_add(S(2i64)); // $ method=S::my_add1
         S(1i64).my_add(3i64); // $ MISSING: method=S::my_add2
         S(1i64).my_add(&3i64); // $ method=S::my_add3
+
+        let x = i64::my_from(73i64); // $ method=MyFrom<i64>::my_from $ SPURIOUS: method=MyFrom<bool>::my_from
+        let y = i64::my_from(true); // $ method=MyFrom<bool>::my_from $ SPURIOUS: method=MyFrom<i64>::my_from
+        let z: i64 = MyFrom::my_from(73i64); // $ MISSING: method=MyFrom<i64>::my_from $ SPURIOUS: method=MyFrom::my_from
+        i64::my_from2(73i64, 0i64); // $ method=MyFrom2<i64>::my_from2 $ SPURIOUS: method=MyFrom2<bool>::my_from2
+        i64::my_from2(true, 0i64); // $ method=MyFrom2<bool>::my_from2 $ SPURIOUS: method=MyFrom2<i64>::my_from2
+        MyFrom2::my_from2(73i64, 0i64); // $ MISSING: method=MyFrom2<i64>::my_from2 $ SPURIOUS: method=MyFrom2::my_from2
     }
 }