wip

Author: hvitved

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

@@ -1331,7 +1331,7 @@ private class BorrowKind extends TBorrowKind {
 }
 
 /**
- * Provides logic for resolving calls to methods.
+ * Provides logic for resolving calls to associated functions.
  *
  * When resolving a method call, a list of [candidate receiver types][1] is constructed
  *
@@ -1365,67 +1365,30 @@ private class BorrowKind extends TBorrowKind {
  *
  * [1]: https://doc.rust-lang.org/reference/expressions/method-call-expr.html#r-expr.method.candidate-receivers
  */
-private module MethodResolution {
-  pragma[nomagic]
-  private predicate functionResolutionDependsOnArgument(
-    ImplItemNode impl, Function f, TypeParameter tp, FunctionPosition pos
-  ) {
-    FunctionOverloading::functionResolutionDependsOnArgument(impl, f, tp, pos)
-    // or
-    // // For inherent implementations of generic types, we also need to check the type being
-    // // implemented. We arbitrarily choose the first type parameter of the type being implemented
-    // // to represent this case.
-    // f = impl.getAnAssocItem() and
-    // not impl.(Impl).hasTrait() and
-    // tp = TTypeParamTypeParameter(impl.resolveSelfTy().getTypeParam(0)) and
-    // pos.isSelf()
-  }
-
+private module AssocFunctionResolution {
+  /**
+   * Holds if the non-method trait function `f` mentions the implicit `Self` type
+   * parameter at `pos`.
+   */
   pragma[nomagic]
-  private predicate traitFunctionResolutionDependsOnArgument0(
-    // todo: copied
-    TraitItemNode trait, NonMethodFunction traitFunction, FunctionPosition pos, ImplItemNode impl,
-    NonMethodFunction implFunction, TypePath path, TypeParameter traitTp
+  private predicate traitSelfTypeParameterOccurrence(
+    TraitItemNode trait, NonMethodFunction f, FunctionPosition pos
   ) {
-    implFunction = impl.getAnAssocItem() and
-    implFunction.implements(traitFunction) and
-    FunctionOverloading::traitTypeParameterOccurrence(trait, traitFunction, _, pos, path, traitTp) and
-    (
-      traitTp = TSelfTypeParameter(trait)
-      or
-      functionResolutionDependsOnArgument(impl, implFunction, traitTp, pos)
-    )
+    FunctionOverloading::traitTypeParameterOccurrence(trait, f, _, pos, _, TSelfTypeParameter(trait))
   }
 
   /**
-   * Holds if resolving the function `implFunction` in `impl` requires inspecting
-   * the type of applied _arguments_ or possibly knowing the return type.
-   *
-   * `traitTp` is a type parameter of the trait being implemented by `impl`, and
-   * we need to check that the type of `f` corresponding to `traitTp` is satisfied
-   * at any one of the positions `pos` in which that type occurs in `f` (at `path`).
-   *
-   * As for method resolution, we always check the type being implemented (corresponding
-   * to `traitTp` being the special `Self` type parameter).
+   * Holds if the non-method function `f` implements a trait function that mentions
+   * the implicit `Self` type parameter at `pos`.
    */
   pragma[nomagic]
-  private predicate traitFunctionResolutionDependsOnArgument(
-    TraitItemNode trait, NonMethodFunction traitFunction, FunctionPosition pos, ImplItemNode impl,
-    NonMethodFunction implFunction, TypePath path, TypeParameter traitTp
+  private predicate traitImplSelfTypeParameterOccurrence(
+    ImplItemNode impl, NonMethodFunction f, FunctionPosition pos
   ) {
-    traitFunctionResolutionDependsOnArgument0(trait, traitFunction, pos, impl, implFunction, path,
-      traitTp) and
-    // Exclude functions where we cannot resolve all relevant type mentions; this allows
-    // for blanket implementations to be applied in those cases
-    forall(TypeParameter traitTp0 |
-      traitFunctionResolutionDependsOnArgument0(trait, traitFunction, _, impl, implFunction, _,
-        traitTp0)
-    |
-      exists(FunctionPosition pos0, TypePath path0 |
-        traitFunctionResolutionDependsOnArgument0(trait, traitFunction, pos0, impl, implFunction,
-          path0, traitTp0) and
-        exists(getAssocFunctionTypeAt(implFunction, impl, pos0, path0))
-      )
+    exists(NonMethodFunction traitFunction |
+      f = impl.getAnAssocItem() and
+      f.implements(traitFunction) and
+      traitSelfTypeParameterOccurrence(_, traitFunction, pos)
     )
   }
 
@@ -1454,48 +1417,10 @@ private module MethodResolution {
     (
       selfPos.isSelfOrTypeQualifier()
       or
-      exists(TraitItemNode trait |
-        traitFunctionResolutionDependsOnArgument0(_, f, selfPos, _, _, _, TSelfTypeParameter(trait))
-        or
-        traitFunctionResolutionDependsOnArgument0(_, _, selfPos, _, f, _, TSelfTypeParameter(trait))
-      )
-    ) and
-    // Exclude functions where we cannot resolve all relevant type mentions; this allows
-    // for blanket implementations to be applied in those cases
-    forall(TraitItemNode trait, NonMethodFunction traitFunction, TypeParameter traitTp0 |
-      traitFunctionResolutionDependsOnArgument0(trait, traitFunction, _, i, f, _, traitTp0)
-    |
-      exists(FunctionPosition pos0, TypePath path0 |
-        traitFunctionResolutionDependsOnArgument0(trait, traitFunction, pos0, i, f, path0, traitTp0) and
-        exists(getAssocFunctionTypeAt(f, i, pos0, path0))
-      )
-    )
-  }
-
-  pragma[nomagic]
-  private predicate testassocFunctionInfo(
-    Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition posAdj,
-    ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType
-  ) {
-    assocFunctionInfo(f, name, arity, i, selfPos, selfType) and
-    strippedType = selfType.getTypeAt(strippedTypePath) and
-    (
-      isComplexRootStripped(strippedTypePath, strippedType)
-      or
-      selfPos.isTypeQualifier() and strippedTypePath.isEmpty()
-    ) and
-    posAdj = selfPos.getFunctionCallAdjusted(f) and
-    (
-      selfPos.isSelfOrTypeQualifier()
+      traitSelfTypeParameterOccurrence(i, f, selfPos)
       or
-      exists(TraitItemNode trait |
-        traitFunctionResolutionDependsOnArgument0(_, f, selfPos, _, _, _, TSelfTypeParameter(trait))
-        or
-        traitFunctionResolutionDependsOnArgument0(_, _, selfPos, _, f, _, TSelfTypeParameter(trait))
-      )
-    ) and
-    not assocFunctionInfo(f, name, arity, selfPos, posAdj, i, selfType, strippedTypePath,
-      strippedType)
+      traitImplSelfTypeParameterOccurrence(i, f, selfPos)
+    )
   }
 
   pragma[nomagic]
@@ -1544,9 +1469,7 @@ private module MethodResolution {
     (
       selfPos.isSelfOrTypeQualifier()
       or
-      traitFunctionResolutionDependsOnArgument0(_, f, selfPos, _, _, _, TSelfTypeParameter(trait))
-      or
-      traitFunctionResolutionDependsOnArgument0(_, _, selfPos, _, f, _, TSelfTypeParameter(trait))
+      traitImplSelfTypeParameterOccurrence(impl, f, selfPos)
     )
   }
 
@@ -1852,24 +1775,6 @@ private module MethodResolution {
       )
     }
 
-    private predicate foo2(
-      FunctionPosition selfPos, DerefChain derefChain, TypePath strippedTypePath, Type strippedType
-    ) {
-      //ImplOrTraitItemNode i
-      this = Debug::getRelevantLocatable() and
-      derefChain.isEmpty() and
-      strippedType =
-        this.getComplexStrippedType(selfPos, derefChain, TNoBorrowKind(), strippedTypePath) and
-      this.hasNoCompatibleTargetCheck(selfPos, derefChain, TNoBorrowKind(), strippedTypePath,
-        getNthLookupType(strippedType, _))
-      // exists(Type t | t = getNthLookupType(strippedType, n) |
-      //   this.hasNoCompatibleNonBlanketLikeTargetCheck(selfPos, derefChain, TSomeBorrowKind(false),
-      //     strippedTypePath, t)
-      // ) and
-      // methodCallNonBlanketCandidate(this, _, selfPos, _, i, _, strippedTypePath, strippedType) //and
-      // not this.hasIncompatibleTarget(i, selfPos, derefChain, TSomeBorrowKind(false), strippedType)
-    }
-
     /**
      * Holds if the candidate receiver type represented by `derefChain` does not
      * have a matching method target.
@@ -1882,16 +1787,6 @@ private module MethodResolution {
       )
     }
 
-    private predicate testhasNoCompatibleTargetNoBorrow(
-      FunctionPosition selfPos, DerefChain derefChain
-    ) {
-      exists(Type strippedType |
-        this.hasNoCompatibleTargetNoBorrowToIndex(selfPos, derefChain, _, strippedType,
-          getLastLookupTypeIndex(strippedType))
-      ) and
-      this = Debug::getRelevantLocatable()
-    }
-
     // forex using recursion
     pragma[nomagic]
     private predicate hasNoCompatibleNonBlanketTargetNoBorrowToIndex(
@@ -1918,29 +1813,6 @@ private module MethodResolution {
       )
     }
 
-    private predicate sdf(
-      FunctionPosition selfPos, DerefChain derefChain, TypePath strippedTypePath, Type strippedType,
-      int n, ImplOrTraitItemNode i
-    ) {
-      (
-        this.supportsAutoDerefAndBorrow() and
-        selfPos.isSelf()
-        or
-        // needed for the `hasNoCompatibleTarget` check in
-        // `ReceiverSatisfiesBlanketLikeConstraintInput::hasBlanketCandidate`
-        derefChain.isEmpty()
-      ) and
-      strippedType =
-        this.getComplexStrippedType(selfPos, derefChain, TNoBorrowKind(), strippedTypePath) and
-      this = Debug::getRelevantLocatable() and
-      exists(Type t | t = getNthLookupType(strippedType, n) |
-        // this.hasNoCompatibleNonBlanketTargetCheck(selfPos, derefChain, TNoBorrowKind(),
-        // strippedTypePath, t)
-        methodCallNonBlanketCandidate(this, _, selfPos, _, i, _, strippedTypePath, strippedType) and
-        not this.hasIncompatibleTarget(i, selfPos, derefChain, TNoBorrowKind(), strippedType)
-      )
-    }
-
     /**
      * Holds if the candidate receiver type represented by `derefChain` does not have
      * a matching non-blanket method target.
@@ -1974,22 +1846,6 @@ private module MethodResolution {
       )
     }
 
-    private predicate foo(
-      FunctionPosition selfPos, DerefChain derefChain, TypePath strippedTypePath, Type strippedType
-    ) {
-      //ImplOrTraitItemNode i
-      this = Debug::getRelevantLocatable() and
-      this.hasNoCompatibleTargetNoBorrow(selfPos, derefChain) and
-      strippedType =
-        this.getComplexStrippedType(selfPos, derefChain, TSomeBorrowKind(false), strippedTypePath) //and
-      // exists(Type t | t = getNthLookupType(strippedType, n) |
-      //   this.hasNoCompatibleNonBlanketLikeTargetCheck(selfPos, derefChain, TSomeBorrowKind(false),
-      //     strippedTypePath, t)
-      // ) and
-      // methodCallNonBlanketCandidate(this, _, selfPos, _, i, _, strippedTypePath, strippedType) //and
-      // not this.hasIncompatibleTarget(i, selfPos, derefChain, TSomeBorrowKind(false), strippedType)
-    }
-
     /**
      * Holds if the candidate receiver type represented by `derefChain`, followed
      * by a shared borrow, does not have a matching method target.
@@ -2425,7 +2281,7 @@ private module MethodResolution {
     pragma[nomagic]
     Function resolveCallTarget(ImplOrTraitItemNode i) {
       result = this.resolveCallTargetCand(i) and
-      not functionResolutionDependsOnArgument(i, result, _, _)
+      not FunctionOverloading::functionResolutionDependsOnArgument(i, result, _, _)
       or
       MethodArgsAreInstantiationsOf::argsAreInstantiationsOf(mc_, i, result)
     }
@@ -2526,28 +2382,6 @@ private module MethodResolution {
         blanketPath.getHead() = borrow.getRefType().getPositionalTypeParameter(0)
       )
     }
-
-    pragma[nomagic]
-    predicate testhasBlanketCandidate(
-      MethodCallCand mcc, ImplItemNode impl, TypePath blanketPath, TypeParam blanketTypeParam
-    ) {
-      exists(MethodCall mc, FunctionPosition pos, BorrowKind borrow |
-        mcc = MkMethodCallCand(mc, _, pos, _, borrow) and
-        blanketPath.isEmpty() and
-        mc = Debug::getRelevantLocatable() and
-        methodCallBlanketLikeCandidate(mc, _, _, pos, impl, _, blanketPath, blanketTypeParam) and
-        impl.isBlanketImplementation() and
-        // Only apply blanket implementations when no other implementations are possible;
-        // this is to account for codebases that use the (unstable) specialization feature
-        // (https://rust-lang.github.io/rfcs/1210-impl-specialization.html), as well as
-        // cases where our blanket implementation filtering is not precise enough.
-        mcc.hasNoCompatibleNonBlanketTarget()
-      |
-        borrow.isNoBorrow()
-        or
-        blanketPath.getHead() = borrow.getRefType().getPositionalTypeParameter(0)
-      )
-    }
   }
 
   private module ReceiverSatisfiesBlanketLikeConstraint =
@@ -2578,17 +2412,6 @@ private module MethodResolution {
       )
     }
 
-    pragma[nomagic]
-    private predicate testpotentialInstantiationOf0(
-      MethodCallCand mcc, ImplOrTraitItemNode i, AssocFunctionType selfType, MethodCall mc,
-      FunctionPosition selfPos, FunctionPosition pos, Function f, string name, int arity,
-      TypePath strippedTypePath, Type strippedType
-    ) {
-      mc = Debug::getRelevantLocatable() and
-      mcc.hasSignature(mc, pos, strippedTypePath, strippedType, name, arity) and
-      methodCallNonBlanketCandidate(mc, f, selfPos, pos, i, selfType, strippedTypePath, strippedType)
-    }
-
     pragma[nomagic]
     predicate potentialInstantiationOf(
       MethodCallCand mcc, TypeAbstraction abs, AssocFunctionType constraint
@@ -2666,7 +2489,7 @@ private module MethodResolution {
    */
   private module MethodArgsAreInstantiationsOfInput implements ArgsAreInstantiationsOfInputSig {
     predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter traitTp, FunctionPosition pos) {
-      functionResolutionDependsOnArgument(i, f, traitTp, pos)
+      FunctionOverloading::functionResolutionDependsOnArgument(i, f, traitTp, pos)
     }
 
     final private class MethodCallFinal = MethodCall;
@@ -2751,7 +2574,7 @@ private module MethodCallMatchingInput implements MatchingWithEnvironmentInputSi
     )
   }
 
-  final private class MethodCallFinal = MethodResolution::MethodCall;
+  final private class MethodCallFinal = AssocFunctionResolution::MethodCall;
 
   class Access extends MethodCallFinal, ContextTyping::ContextTypedCallCand {
     Access() {
@@ -3152,7 +2975,7 @@ private module NonMethodCallMatchingInput implements MatchingInputSig {
       exists(ImplOrTraitItemNodeOption i, NonMethodFunctionDeclaration f |
         result = TNonMethodFunctionDeclaration(i, f)
       |
-        f = this.(MethodResolution::MethodCall).resolveCallTarget(i.asSome(), _, _, _) // mutual recursion; resolving some associated function calls requires resolving types
+        f = this.(AssocFunctionResolution::MethodCall).resolveCallTarget(i.asSome(), _, _, _) // mutual recursion; resolving some associated function calls requires resolving types
         or
         f = this.resolveCallTargetViaPathResolution() and
         f.isDirectlyFor(i)
@@ -3249,7 +3072,7 @@ private module OperationMatchingInput implements MatchingInputSig {
     }
   }
 
-  class Access extends MethodResolution::MethodCallOperation {
+  class Access extends AssocFunctionResolution::MethodCallOperation {
     Type getTypeArgument(TypeArgumentPosition apos, TypePath path) { none() }
 
     pragma[nomagic]
@@ -3970,7 +3793,8 @@ private module Cached {
   cached
   predicate implicitDerefChainBorrow(Expr e, DerefChain derefChain, boolean borrow) {
     exists(BorrowKind bk |
-      any(MethodResolution::MethodCall mc).argumentHasImplicitDerefChainBorrow(e, derefChain, bk) and
+      any(AssocFunctionResolution::MethodCall mc)
+          .argumentHasImplicitDerefChainBorrow(e, derefChain, bk) and
       if bk.isNoBorrow() then borrow = false else borrow = true
     )
     or
@@ -4002,7 +3826,7 @@ private module Cached {
       or
       i instanceof ImplItemNode and dispatch = false
     |
-      result = call.(MethodResolution::MethodCall).resolveCallTarget(i, _, _, _)
+      result = call.(AssocFunctionResolution::MethodCall).resolveCallTarget(i, _, _, _)
     )
   }