wip

Author: hvitved

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

@@ -2445,37 +2445,53 @@ private module AssocFunctionResolution {
      * resolve to a function in an `impl` block for the type of the receiver.
      */
     pragma[nomagic]
-    predicate hasNoInherentTarget() {
+    predicate hasNoInherentTarget0() {
       afc_.hasTrait()
       or
       exists(
         TypePath strippedTypePath, Type strippedType, string name, int arity,
-        TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver
+        TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver,
+        boolean targetMustBeMethod
       |
         // Calls to inherent functions are always of the form `x.m(...)` or `Foo::bar(...)`,
         // where `Foo` is a type. In case `bar` is a method, we can use both the type qualifier
         // and the type of the first argument to rule out candidates
-        selfPosAdj_.isTypeQualifier() and hasReceiver = false
+        selfPosAdj_.isTypeQualifier() and targetMustBeMethod = false
         or
-        selfPosAdj_.asPosition() = 0 and hasReceiver = true
+        selfPosAdj_.asPosition() = 0 and targetMustBeMethod = true
       |
-        afc_.hasSyntacticInfo(name, arity, typeQualifier, traitQualifier, _) and
+        afc_.hasSyntacticInfo(name, arity, typeQualifier, traitQualifier, hasReceiver) and
+        (if hasReceiver = true then targetMustBeMethod = true else any()) and
         this.hasSignature(_, selfPosAdj_, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
           i.isInherent() and
           (
             assocFunctionInfoNonBlanketLikeCheck(_, name, arity, selfPosAdj_, i, _,
-              strippedTypePath, strippedType, typeQualifier, traitQualifier, hasReceiver)
+              strippedTypePath, strippedType, typeQualifier, traitQualifier, targetMustBeMethod)
             or
             assocFunctionInfoNonBlanketLikeTypeParamCheck(_, name, arity, selfPosAdj_, i, _,
-              strippedTypePath, typeQualifier, traitQualifier, hasReceiver)
+              strippedTypePath, typeQualifier, traitQualifier, targetMustBeMethod)
           )
         |
           this.hasIncompatibleInherentTarget(i)
         )
       )
     }
 
+    pragma[nomagic]
+    predicate hasNoInherentTarget() {
+      this.hasNoInherentTarget0() and
+      if exists(getNonTypeParameterTypeQualifier(afc_))
+      then
+        exists(FunctionPosition selfPosAdj |
+          selfPosAdj.isTypeQualifier() and
+          MkAssocFunctionCallCand(afc_, selfPosAdj, _, _)
+              .(AssocFunctionCallCand)
+              .hasNoInherentTarget0()
+        )
+      else any()
+    }
+
     pragma[nomagic]
     private predicate selfArgIsInstantiationOf(ImplOrTraitItemNode i, string name, int arity) {
       SelfArgIsInstantiationOf::argIsInstantiationOf(this, i, _) and

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

@@ -421,7 +421,7 @@ mod inherent_before_trait {
         // <S<i32>_as_Trait>::foo
         fn foo(&self) {
             S::foo(self); // $ MISSING: target=S<i32>::foo
-            S::<i32>::foo(self); // $ MISSING: target=S<i32>::foo
+            S::<i32>::foo(self); // $ target=S<i32>::foo
             self.foo() // $ target=<S<i32>_as_Trait>::foo
         }
 
@@ -437,7 +437,7 @@ mod inherent_before_trait {
         // <S<i64>_as_Trait>::foo
         fn foo(&self) {
             // `S::foo(self);` is not valid
-            S::<i64>::foo(self); // $ MISSING: target=<S<i64>_as_Trait>::foo
+            S::<i64>::foo(self); // $ target=<S<i64>_as_Trait>::foo
             self.foo() // $ target=<S<i64>_as_Trait>::foo
         }