wip

Author: hvitved

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

@@ -2440,42 +2440,61 @@ private module AssocFunctionResolution {
       SelfArgIsNotInstantiationOfInherent::argIsNotInstantiationOf(this, impl, _, _)
     }
 
-    /**
-     * Holds if this function call has no inherent target, i.e., it does not
-     * resolve to a function in an `impl` block for the type of the receiver.
-     */
     pragma[nomagic]
-    predicate hasNoInherentTarget() {
-      afc_.hasTrait()
-      or
+    predicate hasNoInherentTargetCheck() {
       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)
         )
       )
     }
 
+    /**
+     * Holds if this function call has no inherent target, i.e., it does not
+     * resolve to a function in an `impl` block for the type of the receiver.
+     */
+    pragma[nomagic]
+    predicate hasNoInherentTarget() {
+      afc_.hasTrait()
+      or
+      this.hasNoInherentTargetCheck() and
+      if exists(getNonTypeParameterTypeQualifier(afc_)) and not selfPosAdj_.isTypeQualifier()
+      then
+        // If this call is of the form `Foo::bar(x)` and we are resolving with respect to the type
+        // of `x`, then we additionally need to check that the type qualifier does not give rise
+        // to an inherent target
+        exists(FunctionPosition typeQualifierPos |
+          typeQualifierPos.isTypeQualifier() and
+          MkAssocFunctionCallCand(afc_, typeQualifierPos, _, _)
+              .(AssocFunctionCallCand)
+              .hasNoInherentTargetCheck()
+        )
+      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
         }