wip2

Author: hvitved

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

@@ -1407,7 +1407,9 @@ private module AssocFunctionResolution {
    *
    * `selfPosAdj` is the function-call adjusted version of `selfPos`.
    *
-   * `implType` is the type being implemented (`None` when `i` is a trait).
+   * `implType` is the type being implemented by `i` (`None` when `i` is a trait).
+   *
+   * `trait` is the trait being implemented by `i` or `i` itself (`None` when `i` is inherent).
    *
    * `isMethod` indicates whether `f` is a method.
    */
@@ -1451,7 +1453,7 @@ private module AssocFunctionResolution {
   }
 
   pragma[nomagic]
-  private predicate assocFunctionInfoNonBlanketLike0(
+  private predicate assocFunctionInfoNonBlanketLike(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
     TypeOption implType, TypeOption trait, boolean isMethod
@@ -1464,29 +1466,11 @@ private module AssocFunctionResolution {
   pragma[nomagic]
   private predicate assocFunctionInfoNonBlanketLikeTypeParam(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
-    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, TypeParam tp,
-    TypeOption implType, TypeOption trait, boolean isMethod
-  ) {
-    assocFunctionInfo(f, name, arity, selfPos, selfPosAdj, i, selfType, strippedTypePath,
-      TTypeParamTypeParameter(tp), implType, trait, isMethod) and
-    not BlanketImplementation::isBlanketLike(i, _, _)
-  }
-
-  /**
-   * Same as `assocFunctionInfo`, but restricted to non-blanket-like implementations, and
-   * allowing for any `strippedType` when the corresponding type inside `f` is
-   * a type parameter.
-   */
-  pragma[inline]
-  private predicate assocFunctionInfoNonBlanketLike(
-    Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
-    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
+    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath,
     TypeOption implType, TypeOption trait, boolean isMethod
   ) {
-    assocFunctionInfoNonBlanketLike0(f, name, arity, selfPos, selfPosAdj, i, selfType,
-      strippedTypePath, strippedType, implType, trait, isMethod) or
-    assocFunctionInfoNonBlanketLikeTypeParam(f, name, arity, selfPos, selfPosAdj, i, selfType,
-      strippedTypePath, _, implType, trait, isMethod)
+    assocFunctionInfoNonBlanketLike(f, name, arity, selfPos, selfPosAdj, i, selfType,
+      strippedTypePath, TTypeParamTypeParameter(_), implType, trait, isMethod)
   }
 
   /**
@@ -1496,6 +1480,8 @@ private module AssocFunctionResolution {
    *
    * `blanketPath` points to the type `blanketTypeParam` inside `selfType`, which
    * is the type parameter used in the blanket implementation.
+   *
+   * `isMethod` indicates whether `f` is a method.
    */
   pragma[nomagic]
   private predicate assocFunctionSelfInfoBlanketLike(
@@ -1531,14 +1517,14 @@ private module AssocFunctionResolution {
         exists(string name, int arity |
           afc0.hasNameAndArity(name, arity) and
           assocFunctionTraitInfo(name, arity, trait) and
+          // we only need to check visibility of traits that are not mentioned explicitly
           not afc0.hasATrait()
         )
       )
   }
 
   private module AssocFunctionTraitIsVisible = TraitIsVisible<assocFunctionCallTraitCandidate/2>;
 
-  // private predicate callVisibleTraitCandidate = AssocFunctionTraitIsVisible::traitIsVisible/2;
   bindingset[afc, impl]
   pragma[inline_late]
   private predicate callVisibleImplTraitCandidate(AssocFunctionCall afc, ImplItemNode impl) {
@@ -1571,6 +1557,45 @@ private module AssocFunctionResolution {
     )
   }
 
+  bindingset[implType, trait, isMethod]
+  private predicate callMatching(
+    TypeOption implType, TypeOption trait, boolean isMethod, TypeOption typeQualifier,
+    TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    // when present, explicit type qualifier must match the type being implemented
+    typeQualifier = [implType, any(TypeOption non | non.isNone())] and
+    // 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]
+  }
+
+  pragma[nomagic]
+  private predicate assocFunctionInfoNonBlanketLikeCand(
+    Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
+    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
+    TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    exists(TypeOption implType, TypeOption trait, boolean isMethod |
+      assocFunctionInfoNonBlanketLike(f, name, arity, selfPos, selfPosAdj, i, selfType,
+        strippedTypePath, strippedType, implType, trait, isMethod) and
+      callMatching(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
+    )
+  }
+
+  pragma[nomagic]
+  private predicate assocFunctionInfoNonBlanketLikeTypeParamCand(
+    Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
+    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath,
+    TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    exists(TypeOption implType, TypeOption trait, boolean isMethod |
+      assocFunctionInfoNonBlanketLikeTypeParam(f, name, arity, selfPos, selfPosAdj, i, selfType,
+        strippedTypePath, implType, trait, isMethod) and
+      callMatching(implType, trait, isMethod, typeQualifier, traitQualifier, hasReceiver)
+    )
+  }
+
   /**
    * Holds if call `afc` may target function `f` in `i` with type `selfType` at
    * `selfPos`.
@@ -1588,15 +1613,20 @@ private module AssocFunctionResolution {
     AssocFunctionCall afc, Function f, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType
   ) {
-    exists(string name, int arity, TypeOption implType, TypeOption trait, boolean isMethod |
-      callInfo(afc, name, arity, [implType, any(TypeOption non | non.isNone())],
-        [trait, any(TypeOption non | non.isNone())], [false, isMethod]) and
-      assocFunctionInfoNonBlanketLike(f, name, arity, selfPos, selfPosAdj, i, selfType,
-        strippedTypePath, strippedType, implType, trait, isMethod)
+    exists(
+      string name, int arity, TypeOption typeQualifier, TypeOption traitQualifier,
+      boolean hasReceiver
     |
+      callInfo(afc, name, arity, typeQualifier, traitQualifier, hasReceiver) and
       if not afc.hasATrait() and i.(Impl).hasTrait()
       then callVisibleImplTraitCandidate(afc, i)
       else any()
+    |
+      assocFunctionInfoNonBlanketLikeCand(f, name, arity, selfPos, selfPosAdj, i, selfType,
+        strippedTypePath, strippedType, typeQualifier, traitQualifier, hasReceiver)
+      or
+      assocFunctionInfoNonBlanketLikeTypeParamCand(f, name, arity, selfPos, selfPosAdj, i, selfType,
+        strippedTypePath, typeQualifier, traitQualifier, hasReceiver)
     )
   }
 
@@ -2333,8 +2363,12 @@ private module AssocFunctionResolution {
       |
         this.hasSignature(_, selfPosAdj, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
-          assocFunctionInfoNonBlanketLike(_, name, arity, _, selfPosAdj, i, _, strippedTypePath,
-            strippedType, _, _, _) and
+          (
+            assocFunctionInfoNonBlanketLike(_, name, arity, _, selfPosAdj, i, _, strippedTypePath,
+              strippedType, _, _, _) or
+            assocFunctionInfoNonBlanketLikeTypeParam(_, name, arity, _, selfPosAdj, i, _,
+              strippedTypePath, _, _, _)
+          ) and
           i.isInherent()
         |
           this.hasIncompatibleInherentTarget(i)