wip

Author: hvitved

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

@@ -1113,13 +1113,16 @@ private Trait getCallExprTraitQualifier(CallExpr ce) {
   )
 }
 
+pragma[nomagic]
+private predicate nonAssocFunction(ItemNode i) { not i instanceof AssocFunction }
+
 /**
  * A call expression that can resolve to something that is not an associated
  * function, and hence does not need type inference for resolution.
  */
 private class NonAssocCallExpr extends CallExpr {
   NonAssocCallExpr() {
-    forex(ItemNode i | i = CallExprImpl::getResolvedFunction(this) | not i instanceof AssocFunction)
+    forex(ItemNode i | i = CallExprImpl::getResolvedFunction(this) | nonAssocFunction(i))
   }
 
   /**
@@ -1477,55 +1480,6 @@ private module AssocFunctionResolution {
     if f instanceof Method then isMethod = true else isMethod = false
   }
 
-  pragma[nomagic]
-  private predicate assocFunctionInfoNonBlanketLike(
-    Function f, string name, int arity, FunctionPosition selfPosAdj, ImplOrTraitItemNode i,
-    AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType, TypeOption implType,
-    TypeOption trait, boolean isMethod
-  ) {
-    assocFunctionInfo(f, name, arity, selfPosAdj, i, selfType, strippedTypePath, strippedType,
-      implType, trait, isMethod) and
-    not BlanketImplementation::isBlanketLike(i, _, _)
-  }
-
-  pragma[nomagic]
-  private predicate assocFunctionInfoNonBlanketLikeTypeParam(
-    Function f, string name, int arity, FunctionPosition selfPosAdj, ImplOrTraitItemNode i,
-    AssocFunctionType selfType, TypePath strippedTypePath, TypeOption implType, TypeOption trait,
-    boolean isMethod
-  ) {
-    assocFunctionInfoNonBlanketLike(f, name, arity, selfPosAdj, i, selfType, strippedTypePath,
-      TTypeParamTypeParameter(_), implType, trait, isMethod)
-  }
-
-  /**
-   * Holds if associated function `f` with the name `name` and the arity `arity` exists
-   * in blanket (like) implementation `impl` of `trait`, and the type at `selfPosAdj` is
-   * `selfType`.
-   *
-   * `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(
-    Function f, string name, int arity, FunctionPosition selfPosAdj, ImplItemNode impl, Trait trait,
-    AssocFunctionType selfType, TypePath blanketPath, TypeParam blanketTypeParam, boolean isMethod
-  ) {
-    assocFunctionInfoBlanketLike(f, name, arity, impl, trait, selfPosAdj, selfType, blanketPath,
-      blanketTypeParam) and
-    (
-      f instanceof Method and
-      selfPosAdj.asPosition() = 0
-      or
-      selfPosAdj.isTypeQualifier()
-      or
-      traitImplSelfTypeParameterOccurrence(impl, f, selfPosAdj)
-    ) and
-    if f instanceof Method then isMethod = true else isMethod = false
-  }
-
   pragma[nomagic]
   private predicate assocFunctionTraitInfo(string name, int arity, Trait trait) {
     exists(ImplItemNode i |
@@ -1557,9 +1511,9 @@ private module AssocFunctionResolution {
     AssocFunctionTraitIsVisible::traitIsVisible(afc, impl.resolveTraitTy())
   }
 
-  bindingset[implType, trait, isMethod]
+  pragma[inline]
   private predicate callMatching(
-    TypeOption implType, TypeOption trait, boolean isMethod, TypeOption typeQualifier,
+    TypeOption implType, TypeOption trait, Boolean isMethod, TypeOption typeQualifier,
     TypeOption traitQualifier, boolean hasReceiver
   ) {
     // when present, explicit type qualifier must match the type being implemented
@@ -1577,8 +1531,9 @@ private module AssocFunctionResolution {
     TypeOption typeQualifier, TypeOption traitQualifier, boolean hasReceiver
   ) {
     exists(TypeOption implType, TypeOption trait, boolean isMethod |
-      assocFunctionInfoNonBlanketLike(f, name, arity, selfPosAdj, i, selfType, strippedTypePath,
-        strippedType, implType, trait, isMethod) and
+      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)
     )
   }
@@ -1590,8 +1545,9 @@ private module AssocFunctionResolution {
     TypeOption traitQualifier, boolean hasReceiver
   ) {
     exists(TypeOption implType, TypeOption trait, boolean isMethod |
-      assocFunctionInfoNonBlanketLikeTypeParam(f, name, arity, selfPosAdj, i, selfType,
-        strippedTypePath, implType, trait, isMethod) and
+      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)
     )
   }
@@ -1603,9 +1559,8 @@ private module AssocFunctionResolution {
    * `strippedTypePath` points to the type `strippedType` inside `selfType`,
    * which is the (possibly complex-stripped) root type of `selfType`.
    *
-   * This predicate only checks for matching function names and arities, and whether
-   * the trait being implemented by `i` (when `i` is not a trait itself) is visible
-   * at `afc`.
+   * This predicate only performs syntactic checks, such as matching function name
+   * and arity.
    */
   bindingset[afc, strippedTypePath, strippedType]
   pragma[inline_late]
@@ -1637,10 +1592,17 @@ private module AssocFunctionResolution {
     TypeOption traitQualifier, boolean hasReceiver
   ) {
     exists(Trait trait, boolean isMethod |
-      assocFunctionSelfInfoBlanketLike(f, name, arity, selfPosAdj, impl, trait, selfType,
-        blanketPath, blanketTypeParam, isMethod) and
-      traitQualifier = [TypeOption::some(TTrait(trait)), any(TypeOption non | non.isNone())] and
-      hasReceiver = [isMethod, false]
+      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)
+    |
+      isMethod = true and
+      selfPosAdj.asPosition() = 0
+      or
+      selfPosAdj.isTypeQualifier()
+      or
+      traitImplSelfTypeParameterOccurrence(impl, f, selfPosAdj)
     )
   }