wip

Author: hvitved

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

@@ -199,8 +199,7 @@ class AssocFunctionType extends MkAssocFunctionType {
     exists(Function f, ImplOrTraitItemNode i, FunctionPosition pos | this.appliesTo(f, i, pos) |
       result = pos.getTypeMention(f)
       or
-      pos.isSelfOrTypeQualifier() and
-      not f.hasSelfParam() and
+      pos.isTypeQualifier() and
       result = [i.(Impl).getSelfTy().(AstNode), i.(Trait).getName()]
     )
   }
@@ -315,7 +314,7 @@ signature module ArgsAreInstantiationsOfInputSig {
    * If `i` is an inherent implementation, `tp` is a type parameter of the type being
    * implemented, otherwise `tp` is a type parameter of the trait (being implemented).
    *
-   * `posAdj` is one of the positions in `f` in which the relevant type occurs.
+   * `posAdj` is one of the adjusted positions in `f` in which the relevant type occurs.
    */
   predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter tp, FunctionPosition posAdj);
 

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

@@ -1353,7 +1353,7 @@ private class BorrowKind extends TBorrowKind {
 private module AssocFunctionResolution {
   /**
    * Holds if function `f` with the name `name` and the arity `arity` exists in
-   * `i`, and the type at position `posAdj` is `t`.
+   * `i`, and the type at adjusted position `posAdj` is `t`.
    */
   pragma[nomagic]
   private predicate assocFunctionInfo(
@@ -1370,29 +1370,29 @@ private module AssocFunctionResolution {
 
   /**
    * Holds if function `f` with the name `name` and the arity `arity` exists in
-   * blanket (like) implementation `impl` of `trait`, and the type at position
-   * `posAdj` is `t`.
+   * blanket (like) implementation `impl` of `trait`, and the type at adjusted
+   * position `posAdj` is `t`.
    *
    * `blanketPath` points to the type `blanketTypeParam` inside `t`, which
    * is the type parameter used in the blanket implementation.
    */
   pragma[nomagic]
   private predicate assocFunctionInfoBlanketLike(
-    Function f, string name, int arity, ImplItemNode impl, Trait trait, FunctionPosition posAdj,
-    AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
+    Function f, string name, int arity, ImplItemNode impl, TypeOption implType, TypeOption trait,
+    FunctionPosition posAdj, AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam,
+    boolean isMethod
   ) {
     exists(TypePath blanketSelfPath |
-      assocFunctionInfo(f, name, arity, impl, posAdj, t) and
+      assocFunctionInfo(f, name, arity, posAdj, impl, t, _, _, implType, trait, isMethod) and
       TTypeParamTypeParameter(blanketTypeParam) = t.getTypeAt(blanketPath) and
       blanketPath = any(string s) + blanketSelfPath and
-      BlanketImplementation::isBlanketLike(impl, blanketSelfPath, blanketTypeParam) and
-      trait = impl.resolveTraitTy()
+      BlanketImplementation::isBlanketLike(impl, blanketSelfPath, blanketTypeParam)
     )
   }
 
   /**
    * Holds if the non-method trait function `f` mentions the implicit `Self` type
-   * parameter at `posAdj`.
+   * parameter at adjusted position `posAdj`.
    */
   pragma[nomagic]
   private predicate traitSelfTypeParameterOccurrence(
@@ -1407,7 +1407,7 @@ private module AssocFunctionResolution {
 
   /**
    * Holds if the non-method function `f` implements a trait function that mentions
-   * the implicit `Self` type parameter at `posAdj`.
+   * the implicit `Self` type parameter at adjusted position `posAdj`.
    */
   pragma[nomagic]
   private predicate traitImplSelfTypeParameterOccurrence(
@@ -1428,6 +1428,11 @@ private module AssocFunctionResolution {
    * Holds if function `f` with the name `name` and the arity `arity` exists in
    * `i`, and the type at `selfPosAdj` is `selfType`.
    *
+   * `selfPosAdj` is an adjusted position relevant for call resolution: either a position
+   * corresponding to the `self` parameter of `f` (if present); a type qualifier position;
+   * or a position where the implicit `Self` type parameter of some trait is mentioned in
+   * some non-method function `f_trait`, and either `f = f_trait` or `f` implements `f_trait`.
+   *
    * `strippedTypePath` points to the type `strippedType` inside `selfType`,
    * which is the (possibly complex-stripped) root type of `selfType`. For example,
    * if `f` has a `&self` parameter, then `strippedTypePath` is `getRefSharedTypeParameter()`
@@ -1511,19 +1516,32 @@ private module AssocFunctionResolution {
     AssocFunctionTraitIsVisible::traitIsVisible(afc, impl.resolveTraitTy())
   }
 
-  pragma[inline]
-  private predicate callMatching(
-    TypeOption implType, TypeOption trait, Boolean isMethod, TypeOption typeQualifier,
-    TypeOption traitQualifier, boolean hasReceiver
-  ) {
+  bindingset[implType]
+  private predicate callTypeQualifierFilter(TypeOption implType, TypeOption typeQualifier) {
     // when present, explicit type qualifier must match the type being implemented
-    typeQualifier = [implType, any(TypeOption non | non.isNone())] and
+    typeQualifier = [implType, any(TypeOption non | non.isNone())]
+  }
+
+  bindingset[trait, isMethod]
+  pragma[inline_late]
+  private predicate callTraitQualifierAndReceiverFilter(
+    TypeOption trait, Boolean isMethod, TypeOption traitQualifier, boolean hasReceiver
+  ) {
     // when present, explicit trait qualifier must match the trait being implemented or the trait itself
     traitQualifier = [trait, any(TypeOption non | non.isNone())] and
     // when a receiver is present, the target must be a method
     hasReceiver = [isMethod, false]
   }
 
+  bindingset[implType, trait, isMethod]
+  private predicate callFilter(
+    TypeOption implType, TypeOption trait, Boolean isMethod, TypeOption typeQualifier,
+    TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    callTypeQualifierFilter(implType, typeQualifier) and
+    callTraitQualifierAndReceiverFilter(trait, isMethod, traitQualifier, hasReceiver)
+  }
+
   pragma[nomagic]
   private predicate assocFunctionInfoNonBlanketLikeCand(
     Function f, string name, int arity, FunctionPosition selfPosAdj, ImplOrTraitItemNode i,
@@ -1534,7 +1552,7 @@ private module AssocFunctionResolution {
       assocFunctionInfo(f, name, arity, selfPosAdj, i, selfType, strippedTypePath, strippedType,
         implType, trait, isMethod) and
       not BlanketImplementation::isBlanketLike(i, _, _) and
-      callMatching(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
+      callFilter(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
     )
   }
 
@@ -1548,7 +1566,7 @@ private module AssocFunctionResolution {
       assocFunctionInfo(f, name, arity, selfPosAdj, i, selfType, strippedTypePath,
         TTypeParamTypeParameter(_), implType, trait, isMethod) and
       not BlanketImplementation::isBlanketLike(i, _, _) and
-      callMatching(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
+      callFilter(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
     )
   }
 
@@ -1586,17 +1604,14 @@ private module AssocFunctionResolution {
   }
 
   pragma[nomagic]
-  private predicate assocFunctionSelfInfoBlanketLikeCand(
+  private predicate assocFunctionSelfInfoBlanketLikeCand0(
     Function f, string name, int arity, FunctionPosition selfPosAdj, ImplItemNode impl,
     AssocFunctionType selfType, TypePath blanketPath, TypeParam blanketTypeParam,
-    TypeOption traitQualifier, boolean hasReceiver
+    TypeOption implType, TypeOption trait, boolean isMethod
   ) {
-    exists(Trait trait, boolean isMethod |
-      assocFunctionInfoBlanketLike(f, name, arity, impl, trait, selfPosAdj, selfType, blanketPath,
-        blanketTypeParam) and
-      (if f instanceof Method then isMethod = true else isMethod = false) and
-      callMatching(_, TypeOption::some(TTrait(trait)), isMethod, _, traitQualifier, hasReceiver)
-    |
+    assocFunctionInfoBlanketLike(f, name, arity, impl, implType, trait, selfPosAdj, selfType,
+      blanketPath, blanketTypeParam, isMethod) and
+    (
       isMethod = true and
       selfPosAdj.asPosition() = 0
       or
@@ -1606,6 +1621,25 @@ private module AssocFunctionResolution {
     )
   }
 
+  bindingset[name, arity, typeQualifier, traitQualifier, hasReceiver]
+  pragma[inline_late]
+  private predicate assocFunctionSelfInfoBlanketLikeCand(
+    Function f, string name, int arity, FunctionPosition selfPosAdj, ImplItemNode impl,
+    AssocFunctionType selfType, TypePath blanketPath, TypeParam blanketTypeParam,
+    TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    exists(TypeOption implType, TypeOption trait, boolean isMethod |
+      assocFunctionSelfInfoBlanketLikeCand0(f, name, arity, selfPosAdj, impl, selfType, blanketPath,
+        blanketTypeParam, implType, trait, isMethod) and
+      (
+        if impl.isBlanketImplementation()
+        then any()
+        else callTypeQualifierFilter(implType, typeQualifier)
+      ) and
+      callTraitQualifierAndReceiverFilter(trait, isMethod, traitQualifier, hasReceiver)
+    )
+  }
+
   /**
    * Holds if call `afc` may target function `f` in blanket (like) implementation
    * `impl` with type `selfType` at `selfPosAdj`.
@@ -1623,10 +1657,13 @@ private module AssocFunctionResolution {
     AssocFunctionCall afc, Function f, FunctionPosition selfPosAdj, ImplItemNode impl,
     AssocFunctionType self, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
-    exists(string name, int arity, TypeOption traitQualifier, boolean hasReceiver |
-      afc.hasSyntacticInfo(name, arity, _, traitQualifier, hasReceiver) and
+    exists(
+      string name, int arity, TypeOption typeQualifier, TypeOption traitQualifier,
+      boolean hasReceiver
+    |
+      afc.hasSyntacticInfo(name, arity, typeQualifier, traitQualifier, hasReceiver) and
       assocFunctionSelfInfoBlanketLikeCand(f, name, arity, selfPosAdj, impl, self, blanketPath,
-        blanketTypeParam, traitQualifier, hasReceiver)
+        blanketTypeParam, typeQualifier, traitQualifier, hasReceiver)
     |
       if not afc.hasATrait() then callVisibleImplTraitCandidate(afc, impl) else any()
     )