wip2

Author: hvitved

rust/ql/lib/codeql/rust/internal/typeinference/FunctionOverloading.qll

@@ -126,37 +126,50 @@ private predicate functionResolutionDependsOnArgument0(
 
 /**
  * Holds if resolving the function `f` in `impl` requires inspecting the type
- * of applied _arguments_ at position `pos` (including the return type) in
- * order to determine whether it is the correct resolution.
+ * of applied _arguments_ at position `pos` (possibly including the return type)
+ * in order to determine whether it is the correct resolution.
  */
 pragma[nomagic]
 predicate functionResolutionDependsOnArgument(
   ImplItemNode impl, Function f, TypeParameter traitTp, FunctionPosition pos, TypePath path,
   Type type
 ) {
   exists(string functionName |
-    functionResolutionDependsOnArgument0(impl, f, functionName, traitTp, pos, path, type)
+    functionResolutionDependsOnArgument0(impl, f, functionName, traitTp, pos, path, type) and
+    not pos.isSelf()
   |
-    pos.isPosition()
-    or
-    // Only disambiguate based on return type when all other positions are trivially
-    // satisfied for all arguments.
-    pos.isReturn() and
-    forall(FunctionPosition pos0, TypePath path0, Type type0 |
-      pos0.isPosition() and
-      functionResolutionDependsOnArgument0(impl, f, _, _, pos0, path0, type0)
+    exists(FunctionPosition pos0 |
+      functionResolutionDependsOnArgument0(impl, f, functionName, traitTp, pos0, _, _)
     |
-      type0.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
+      pos0.isPosition()
       or
-      forall(ImplItemNode impl1, Function f1, Type type1 |
-        implSiblings(_, impl, impl1) and
-        f1 = impl1.getASuccessor(functionName) and
-        type1 = getAssocFunctionTypeAt(f1, impl1, pos0, path0)
-      |
-        type1.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
-        or
-        type0 = type1
+      pos0.isReturn() and
+      not exists(FunctionPosition pos1 |
+        functionResolutionDependsOnArgument0(impl, f, functionName, _, pos1, _, _) and
+        pos1.isPosition()
       )
     )
+    // |
+    //   pos.isPosition()
+    //   or
+    //   // Only disambiguate based on return type when all other positions are trivially
+    //   // satisfied for all arguments.
+    //   pos.isReturn() and
+    //   forall(FunctionPosition pos0, TypePath path0, Type type0 |
+    //     pos0.isPosition() and
+    //     functionResolutionDependsOnArgument0(impl, f, _, _, pos0, path0, type0)
+    //   |
+    //     type0.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
+    //     or
+    //     forall(ImplItemNode impl1, Function f1, Type type1 |
+    //       implSiblings(_, impl, impl1) and
+    //       f1 = impl1.getASuccessor(functionName) and
+    //       type1 = getAssocFunctionTypeAt(f1, impl1, pos0, path0)
+    //     |
+    //       type1.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
+    //       or
+    //       type0 = type1
+    //     )
+    //   )
   )
 }

rust/ql/lib/codeql/rust/internal/typeinference/FunctionType.qll

@@ -298,6 +298,8 @@ signature module ArgsAreInstantiationsOfInputSig {
    * we need to check that the type of `f` for `traitTp` is satisfied.
    *
    * `pos` is one of the positions in `f` in which the relevant type occours.
+   *
+   * For example, i
    */
   predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter traitTp, FunctionPosition pos);
 

rust/ql/lib/codeql/rust/internal/typeinference/TypeInference.qll

@@ -1283,8 +1283,9 @@ private class BorrowKind extends TBorrowKind {
 // for now, we do not handle ambiguous targets when one of the types is itself
 // a constrained type parameter; we should be checking the constraints in this case
 private predicate typeCanBeUsedForDisambiguation(Type t) {
-  not t instanceof TypeParameter or
-  t.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
+  any()
+  // not t instanceof TypeParameter or
+  // t.(TypeParamTypeParameter).getTypeParam() = any(TypeParam tp | not tp.hasTypeBound())
 }
 
 /**
@@ -2952,8 +2953,6 @@ private module NonMethodResolution {
   {
     predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter traitTp, FunctionPosition pos) {
       exists(Type t0 | typeCanBeUsedForDisambiguation(t0) |
-        // FunctionOverloading::functionResolutionDependsOnArgument(i, f, pos, _, t0)
-        // or
         traitFunctionDependsOnPos2(_, _, pos, t0, i, f, traitTp)
       )
     }
@@ -3009,6 +3008,7 @@ private module NonMethodResolution {
       or
       // match against the trait function itself
       exists(Trait trait |
+        i = trait and
         FunctionOverloading::traitTypeParameterOccurrence(trait, f, _, pos, _, traitTp) and
         traitTp = TSelfTypeParameter(trait)
       )

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

@@ -10392,6 +10392,7 @@ inferType
 | main.rs:2220:26:2220:29 | 2i64 |  | {EXTERNAL LOCATION} | i64 |
 | main.rs:2221:9:2221:15 | S(...) |  | main.rs:2104:5:2104:19 | S |
 | main.rs:2221:9:2221:15 | S(...) | T | {EXTERNAL LOCATION} | i64 |
+| main.rs:2221:9:2221:28 | ... .my_add(...) |  | main.rs:2104:5:2104:19 | S |
 | main.rs:2221:11:2221:14 | 1i64 |  | {EXTERNAL LOCATION} | i64 |
 | main.rs:2221:24:2221:27 | 3i64 |  | {EXTERNAL LOCATION} | i64 |
 | main.rs:2222:9:2222:15 | S(...) |  | main.rs:2104:5:2104:19 | S |
@@ -14020,3 +14021,6 @@ inferType
 | raw_pointer.rs:59:5:59:30 | raw_type_from_deref(...) |  | {EXTERNAL LOCATION} | () |
 | raw_pointer.rs:59:25:59:29 | false |  | {EXTERNAL LOCATION} | bool |
 testFailures
+| main.rs:2220:9:2220:31 | ... .my_add(...) | Unexpected result: target=S::my_add2 |
+| main.rs:2221:9:2221:28 | ... .my_add(...) | Fixed missing result: target=S::my_add2 |
+| main.rs:2222:9:2222:29 | ... .my_add(...) | Unexpected result: target=S::my_add2 |