wip3

Author: hvitved

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

@@ -2732,15 +2732,6 @@ private module NonMethodResolution {
     /** Holds if this call targets a trait. */
     predicate hasTrait() { exists(this.getTrait()) }
 
-    pragma[nomagic]
-    NonMethodFunction resolveCallTargetNonBlanketCand(ImplItemNode i) {
-      not this.hasTrait() and
-      result = this.getPathResolutionResolved() and
-      result = i.getASuccessor(_) and
-      not exists(this.resolveCallTargetViaPathResolution())
-      // FunctionOverloading::functionResolutionDependsOnArgument(i, result, _, _, _)
-    }
-
     AstNode getNodeAt(FunctionPosition pos) {
       result = this.getSyntacticArgument(pos.asArgumentPosition())
       or
@@ -2752,7 +2743,16 @@ private module NonMethodResolution {
     }
 
     pragma[nomagic]
-    predicate resolveCallTargetBlanketLikeCandidate(
+    NonMethodFunction resolveCallTargetNonBlanketCand(ImplItemNode i) {
+      not this.hasTrait() and
+      result = this.getPathResolutionResolved() and
+      result = i.getASuccessor(_) and
+      not exists(this.resolveCallTargetViaPathResolution()) and
+      FunctionOverloading::functionResolutionDependsOnArgument(i, result, _, _)
+    }
+
+    pragma[nomagic]
+    predicate resolveCallTargetBlanketLikeCand(
       ImplItemNode impl, FunctionPosition pos, TypePath blanketPath, TypeParam blanketTypeParam
     ) {
       exists(string name, int arity, Trait trait, AssocFunctionType t |
@@ -2761,6 +2761,10 @@ private module NonMethodResolution {
         functionInfoBlanketLikeRelevantPos(_, name, arity, impl, trait, pos, t, blanketPath,
           blanketTypeParam) and
         BlanketTraitIsVisible::traitIsVisible(this, trait)
+      |
+        not this.hasTrait()
+        or
+        trait = this.getTrait()
       )
     }
 
@@ -2776,8 +2780,7 @@ private module NonMethodResolution {
      */
     pragma[nomagic]
     predicate hasNoCompatibleNonBlanketTarget() {
-      // not this = Debug::getRelevantLocatable() and // todo
-      this.resolveCallTargetBlanketLikeCandidate(_, _, _, _) and
+      this.resolveCallTargetBlanketLikeCand(_, _, _, _) and
       not exists(this.resolveCallTargetViaPathResolution()) and
       forall(ImplOrTraitItemNode i, Function f |
         this.(NonMethodArgsAreInstantiationsOfNonBlanketInput1::Call).hasTargetCand(i, f)
@@ -2814,9 +2817,7 @@ private module NonMethodResolution {
       result = this.resolveCallTargetBlanketCand(i) and
       not FunctionOverloading::functionResolutionDependsOnArgument(_, result, _, _)
       or
-      NonMethodArgsAreInstantiationsOfBlanket1::argsAreInstantiationsOf(this, i, result)
-      or
-      NonMethodArgsAreInstantiationsOfBlanket2::argsAreInstantiationsOf(this, i, result)
+      NonMethodArgsAreInstantiationsOfBlanket::argsAreInstantiationsOf(this, i, result)
       or
       NonMethodArgsAreInstantiationsOfNonBlanket1::argsAreInstantiationsOf(this, i, result)
       or
@@ -2833,7 +2834,7 @@ private module NonMethodResolution {
 
   private newtype TCallAndBlanketPos =
     MkCallAndBlanketPos(NonMethodCall fc, FunctionPosition pos) {
-      fc.resolveCallTargetBlanketLikeCandidate(_, pos, _, _)
+      fc.resolveCallTargetBlanketLikeCand(_, pos, _, _)
     }
 
   /** A call tagged with a position. */
@@ -2859,7 +2860,7 @@ private module NonMethodResolution {
     ) {
       exists(NonMethodCall fc, FunctionPosition pos |
         fcp = MkCallAndBlanketPos(fc, pos) and
-        fc.resolveCallTargetBlanketLikeCandidate(impl, pos, blanketPath, blanketTypeParam) and
+        fc.resolveCallTargetBlanketLikeCand(impl, pos, blanketPath, blanketTypeParam) 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
@@ -2916,7 +2917,7 @@ private module NonMethodResolution {
     )
   }
 
-  private module NonMethodArgsAreInstantiationsOfBlanketInput1 implements
+  private module NonMethodArgsAreInstantiationsOfBlanketInput implements
     ArgsAreInstantiationsOfInputSig
   {
     predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter traitTp, FunctionPosition pos) {
@@ -2933,30 +2934,8 @@ private module NonMethodResolution {
     }
   }
 
-  private module NonMethodArgsAreInstantiationsOfBlanketInput2 implements
-    ArgsAreInstantiationsOfInputSig
-  {
-    predicate toCheck(ImplOrTraitItemNode i, Function f, TypeParameter traitTp, FunctionPosition pos) {
-      traitFunctionDependsOnPos2(_, _, pos, i, f, traitTp)
-    }
-
-    final class Call extends NonMethodCall {
-      // Call() { this = Debug::getRelevantLocatable() } // todo
-      Type getArgType(FunctionPosition pos, TypePath path) { result = getArgType(this, pos, path) }
-
-      predicate hasTargetCand(ImplOrTraitItemNode i, Function f) {
-        hasTraitResolvedCand(this, i, f) and
-        BlanketImplementation::isBlanketLike(i, _, _) and
-        (this.hasNoCompatibleNonBlanketTarget() or not i.(ImplItemNode).isBlanketImplementation()) // todo: removing this line makes the pred below work
-      }
-    }
-  }
-
-  private module NonMethodArgsAreInstantiationsOfBlanket1 =
-    ArgsAreInstantiationsOf<NonMethodArgsAreInstantiationsOfBlanketInput1>;
-
-  private module NonMethodArgsAreInstantiationsOfBlanket2 =
-    ArgsAreInstantiationsOf<NonMethodArgsAreInstantiationsOfBlanketInput2>;
+  private module NonMethodArgsAreInstantiationsOfBlanket =
+    ArgsAreInstantiationsOf<NonMethodArgsAreInstantiationsOfBlanketInput>;
 
   private module NonMethodArgsAreInstantiationsOfNonBlanketInput1 implements
     ArgsAreInstantiationsOfInputSig
@@ -2982,6 +2961,7 @@ private module NonMethodResolution {
       // NonMethodArgsAreInstantiationsOfBlanketInput::toCheck(i, f, pos, t)
       traitFunctionDependsOnPos2(_, _, pos, i, f, traitTp)
       or
+      // FunctionOverloading::functionResolutionDependsOnArgument(i, f, traitTp, pos)
       // match against the trait function itself
       exists(Trait trait |
         i = trait and