wip7

Author: hvitved

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

@@ -197,7 +197,7 @@ class AssocFunctionType extends MkAssocFunctionType {
     exists(Function f, ImplOrTraitItemNode i, FunctionPosition pos | this.appliesTo(f, i, pos) |
       result = pos.getTypeMention(f)
       or
-      pos.isSelf() and
+      pos.isSelfOrTypeQualifier() and
       not f.hasSelfParam() and
       result = [i.(Impl).getSelfTy().(AstNode), i.(Trait).getName()]
     )

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

@@ -1385,6 +1385,38 @@ private module MethodResolution {
     )
   }
 
+  /**
+   * 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).
+   */
+  pragma[nomagic]
+  private predicate traitFunctionResolutionDependsOnArgument(
+    TraitItemNode trait, NonMethodFunction traitFunction, FunctionPosition pos, ImplItemNode impl,
+    NonMethodFunction implFunction, TypePath path, TypeParameter traitTp
+  ) {
+    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))
+      )
+    )
+  }
+
   /**
    * Holds if function `f` with the name `name` and the arity `arity` exists in
    * `i`, and the type of the `self` parameter is `selfType`.
@@ -1415,9 +1447,45 @@ private module MethodResolution {
         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()
+      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)
+  }
+
   pragma[nomagic]
   private predicate assocFunctionInfoTypeParam(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition posAdj,
@@ -1648,6 +1716,13 @@ private module MethodResolution {
             _, derefChain, borrow), i, _, path) and
         path.isCons(root.getATypeParameter(), _)
       )
+      or
+      exists(AssocFunctionType selfType |
+        ReceiverIsInstantiationOfSelfParam::argIsInstantiationOf(MkMethodCallCand(this, selfPos, _,
+            derefChain, borrow), i, selfType) and
+        MethodArgsAreInstantiationsOf::argsAreNotInstantiationsOf(this, i, _) and
+        root = selfType.getTypeAt(TypePath::nil())
+      )
     }
 
     /**
@@ -1756,6 +1831,24 @@ 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.
@@ -1768,6 +1861,16 @@ 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(
@@ -1794,6 +1897,29 @@ 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.
@@ -1827,6 +1953,22 @@ 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.
@@ -2367,6 +2509,28 @@ 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 =
@@ -2397,6 +2561,22 @@ private module MethodResolution {
       )
     }
 
+    pragma[nomagic]
+    private predicate testpotentialInstantiationOf0(
+      MethodCallCand mcc, ImplOrTraitItemNode i, AssocFunctionType selfType, MethodCall mc,
+      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, _, pos, i, selfType, strippedTypePath, strippedType)
+        or
+        methodCallBlanketLikeCandidate(mc, f, _, pos, i, selfType, _, _) and
+        ReceiverSatisfiesBlanketLikeConstraint::satisfiesBlanketConstraint(mcc, i)
+      )
+    }
+
     pragma[nomagic]
     predicate potentialInstantiationOf(
       MethodCallCand mcc, TypeAbstraction abs, AssocFunctionType constraint
@@ -3936,8 +4116,8 @@ private module Debug {
   Locatable getRelevantLocatable() {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
-      filepath.matches("%/main.rs") and
-      startline = 661
+      filepath.matches("%/overloading.rs") and
+      startline = 399
     )
   }