wip4

Author: hvitved

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

@@ -1162,8 +1162,7 @@ private module MethodCallResolution {
       mc.isMethodCall(name, arity) and
       methodCandidate(type, name, arity, i, self, selfPath, selfType)
     |
-      // not CertainTypeInference::inferCertainType(mc.getReceiver(), TypePath::nil()) != type
-      not exists(i.(ImplItemNode).resolveTraitTy())
+      not i.(Impl).hasTrait()
       or
       methodCallVisibleImplTraitCandidate(mc, i)
       or
@@ -1172,6 +1171,18 @@ private module MethodCallResolution {
     )
   }
 
+  private class RawImplOrTrait = @impl or @trait;
+
+  private import codeql.rust.elements.internal.generated.Synth
+
+  private predicate id(RawImplOrTrait x, RawImplOrTrait y) { x = y }
+
+  private predicate idOfRaw(RawImplOrTrait x, int y) = equivalenceRelation(id/2)(x, y)
+
+  private int idOfImplOrTraitItemNode(AstNode node) {
+    idOfRaw(Synth::convertAstNodeToRaw(node), result)
+  }
+
   /**
    * A method call.
    *
@@ -1227,30 +1238,53 @@ private module MethodCallResolution {
 
     pragma[nomagic]
     private predicate isMethodCall0(Type type, string name, int arity, string derefChainBorrow) {
-      type = this.getACandidateReceiverTypeAt(TypePath::nil(), derefChainBorrow) and
-      this.isMethodCall(name, arity)
+      exists(Type t |
+        t = this.getACandidateReceiverTypeAt(TypePath::nil(), derefChainBorrow) and
+        this.isMethodCall(name, arity)
+      |
+        not exists(getATraitBound(t)) and
+        type = t
+        or
+        type = TTrait(getATraitBound(t))
+      )
     }
 
     pragma[nomagic]
     private predicate isNotCandidate(
       ImplOrTraitItemNode i, FunctionPositionType self, string derefChainBorrow
     ) {
-      IsInstantiationOf<MethodCallCand, FunctionPositionType, MethodCallIsInstantiationOfInput>::isNotInstantiationOf(MkMethodCallCand(this,
+      IsInstantiationOf<MethodCallCand, FunctionPositionType, MethodCallIsInstantiationOfInput2>::isNotInstantiationOf(MkMethodCallCand(this,
           derefChainBorrow), i, self)
     }
 
+    // pragma[nomagic]
+    // predicate blah(
+    //   Type type, ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType,
+    //   string derefChainBorrow
+    // ) {
+    //   selfType != this.getACandidateReceiverTypeAt(selfPath, derefChainBorrow) and
+    //   methodCallCandidate(this, type, i, self, selfPath, selfType)
+    // }
+    // idOfImplOrTraitItemNode
+    // pragma[nomagic]
+    // private ImplOrTraitItemNode getARankedCandidate(TypePath path, string derefChain) {
+    //   result = this.getACandidateReceiverTypeAtNoBorrow(path, derefChain) and
+    //   exists(Type type, string name, int arity, string derefChainBorrow |
+    //     derefChainBorrow = derefChain + ";" and
+    //     not derefChain.matches("%.ref") and // no need to try a borrow if the last thing we did was a deref
+    //     this.isMethodCall0(type, name, arity, derefChainBorrow)
+    //   |
+    //     forall(ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType |
+    //       methodCallCandidate(this, type, i, self, selfPath, selfType)
+    //     |
+    //       this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+    //       or
+    //       this.isNotCandidate(i, self, derefChainBorrow)
+    //     )
+    //   )
+    // }
     pragma[nomagic]
-    predicate blah(
-      Type type, ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType,
-      string derefChainBorrow
-    ) {
-      selfType != this.getACandidateReceiverTypeAt(selfPath, derefChainBorrow) and
-      methodCallCandidate(this, type, i, self, selfPath, selfType)
-    }
-
-    pragma[nomagic]
-    private Type getACandidateReceiverTypeAtNoBorrowNoMatch(TypePath path, string derefChain) {
-      result = this.getACandidateReceiverTypeAtNoBorrow(path, derefChain) and
+    private predicate getACandidateReceiverTypeAtNoBorrowNoMatch0(string derefChain) {
       exists(Type type, string name, int arity, string derefChainBorrow |
         derefChainBorrow = derefChain + ";" and
         not derefChain.matches("%.ref") and // no need to try a borrow if the last thing we did was a deref
@@ -1259,30 +1293,66 @@ private module MethodCallResolution {
         forall(ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType |
           methodCallCandidate(this, type, i, self, selfPath, selfType)
         |
-          this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
-          or
+          // this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+          // or
           this.isNotCandidate(i, self, derefChainBorrow)
         )
       )
     }
 
     pragma[nomagic]
-    private Type getACandidateReceiverTypeAtNoMatch(TypePath path, string derefChain) {
-      result = this.getACandidateReceiverTypeAtNoBorrowNoMatch(path, derefChain) and
+    private Type getACandidateReceiverTypeAtNoBorrowNoMatch(TypePath path, string derefChain) {
+      result = this.getACandidateReceiverTypeAtNoBorrow(path, derefChain) and
+      this.getACandidateReceiverTypeAtNoBorrowNoMatch0(derefChain)
+      // exists(Type type, string name, int arity, string derefChainBorrow |
+      //   derefChainBorrow = derefChain + ";" and
+      //   not derefChain.matches("%.ref") and // no need to try a borrow if the last thing we did was a deref
+      //   this.isMethodCall0(type, name, arity, derefChainBorrow)
+      // |
+      //   forall(ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType |
+      //     methodCallCandidate(this, type, i, self, selfPath, selfType)
+      //   |
+      //     this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+      //     or
+      //     this.isNotCandidate(i, self, derefChainBorrow)
+      //   )
+      // )
+    }
+
+    pragma[nomagic]
+    private predicate getACandidateReceiverTypeAtNoMatch0(string derefChain) {
       exists(Type type, string name, int arity, string derefChainBorrow |
         derefChainBorrow = derefChain + ";borrow" and
         this.isMethodCall0(type, name, arity, derefChainBorrow)
       |
         forall(ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType |
           methodCallCandidate(this, type, i, self, selfPath, selfType)
         |
-          this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
-          or
+          // this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+          // or
           this.isNotCandidate(i, self, derefChainBorrow)
         )
       )
     }
 
+    pragma[nomagic]
+    private Type getACandidateReceiverTypeAtNoMatch(TypePath path, string derefChain) {
+      result = this.getACandidateReceiverTypeAtNoBorrowNoMatch(path, derefChain) and
+      this.getACandidateReceiverTypeAtNoMatch0(derefChain)
+      // exists(Type type, string name, int arity, string derefChainBorrow |
+      //   derefChainBorrow = derefChain + ";borrow" and
+      //   this.isMethodCall0(type, name, arity, derefChainBorrow)
+      // |
+      //   forall(ImplOrTraitItemNode i, FunctionPositionType self, TypePath selfPath, Type selfType |
+      //     methodCallCandidate(this, type, i, self, selfPath, selfType)
+      //   |
+      //     this.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+      //     or
+      //     this.isNotCandidate(i, self, derefChainBorrow)
+      //   )
+      // )
+    }
+
     /**
      * Gets a [candidate receiver type][1] of this method call at `path`.
      *
@@ -1401,14 +1471,13 @@ private module MethodCallResolution {
         impl, _)
     }
 
-    pragma[nomagic]
-    private predicate blah(
-      Type type, Impl i, FunctionPositionType self, TypePath selfPath, Type selfType
-    ) {
-      not i.hasTrait() and
-      mc_.blah(type, i, self, selfPath, selfType, derefChainBorrow)
-    }
-
+    // pragma[nomagic]
+    // private predicate blah(
+    //   Type type, Impl i, FunctionPositionType self, TypePath selfPath, Type selfType
+    // ) {
+    //   not i.hasTrait() and
+    //   mc_.blah(type, i, self, selfPath, selfType, derefChainBorrow)
+    // }
     /**
      * Holds if this method call has no inherent target, i.e., it does not
      * resolve to a method in an `impl` block for the type of the receiver.
@@ -1421,8 +1490,8 @@ private module MethodCallResolution {
           methodCandidate(type, name, arity, i, self, selfPath, selfType) and
           not i.hasTrait()
         |
-          this.blah(type, i, self, selfPath, selfType)
-          or
+          // this.blah(type, i, self, selfPath, selfType)
+          // or
           this.isNotInherentTarget(i)
           // forall(Impl impl |
           //   methodCandidate(type, name, arity, impl, _, _, _) and
@@ -1502,14 +1571,33 @@ private module MethodCallResolution {
     }
   }
 
+  private module MethodCallIsInstantiationOfInput2 implements
+    IsInstantiationOfInputSig<MethodCallCand, FunctionPositionType>
+  {
+    pragma[nomagic]
+    predicate potentialInstantiationOf(
+      MethodCallCand mcc, TypeAbstraction abs, FunctionPositionType constraint
+    ) {
+      exists(MethodCall mc, string name, int arity, Type rootType |
+        mcc.isMethodCall(mc, TypePath::nil(), rootType, name, arity) and
+        methodCallCandidate(mc, rootType, abs, constraint, _, _)
+        // mc = Debug::getRelevantLocatable()
+      )
+    }
+
+    predicate relevantTypeMention(FunctionPositionType constraint) {
+      methodCallCandidate(_, _, _, constraint, _, _)
+    }
+  }
+
   private module MethodCallIsNotInstantiationOfInput implements
     IsInstantiationOfInputSig<MethodCallCand, FunctionPositionType>
   {
     pragma[nomagic]
     predicate potentialInstantiationOf(
       MethodCallCand mcc, TypeAbstraction abs, FunctionPositionType constraint
     ) {
-      MethodCallIsInstantiationOfInput::potentialInstantiationOf(mcc, abs, constraint) and
+      MethodCallIsInstantiationOfInput2::potentialInstantiationOf(mcc, abs, constraint) and
       abs = any(Impl i | not i.hasTrait())
     }