wip2

Author: hvitved

rust/ql/lib/codeql/rust/elements/internal/TypeParamImpl.qll

@@ -47,6 +47,9 @@ module Impl {
      */
     TypeBound getATypeBound() { result = this.getTypeBound(_) }
 
+    /** Holds if this type parameter has at least one type bound. */
+    predicate hasTypeBound() { exists(this.getATypeBound()) }
+
     override string toAbbreviatedString() { result = this.getName().getText() }
 
     override string toStringImpl() { result = this.getName().getText() }

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

@@ -840,7 +840,7 @@ private predicate functionInfoBlanket(
 ) {
   functionInfo(f, name, arity, impl, pos, t) and
   TTypeParamTypeParameter(blanketTypeParam) = t.getTypeAt(blanketPath) and
-  blanketTypeParam = impl.getBlanketImplementationTypeParam() and
+  MethodResolution::isBlanketLike(impl, blanketTypeParam) and
   trait = impl.resolveTraitTy()
 }
 
@@ -991,6 +991,17 @@ private module MethodResolution {
     methodInfo(m, name, arity, i, selfType, strippedTypePath, TTypeParamTypeParameter(tp))
   }
 
+  predicate isBlanketLike(ImplItemNode i, TypeParam tp) {
+    tp = i.getBlanketImplementationTypeParam()
+    // or
+    // exists(TypeMention tm, Type root, TypeParameter tp0 |
+    //   tm = i.(Impl).getSelfTy() and
+    //   complexSelfRoot(root, tp0) and
+    //   tm.resolveType() = root and
+    //   tm.resolveTypeAt(TypePath::singleton(tp0)) = TTypeParamTypeParameter(tp)
+    // )
+  }
+
   /**
    * Same as `methodInfo`, but restricted to non-blanket implementations, and
    * allowing for any `strippedType` when the corresponding type inside `m` is
@@ -1005,7 +1016,7 @@ private module MethodResolution {
       methodInfo(m, name, arity, i, selfType, strippedTypePath, strippedType) or
       methodInfoTypeParam(m, name, arity, i, selfType, strippedTypePath, _)
     ) and
-    not i.(ImplItemNode).isBlanketImplementation()
+    not isBlanketLike(i, _)
   }
 
   /**
@@ -1193,6 +1204,10 @@ private module MethodResolution {
     private predicate hasIncompatibleTarget(ImplOrTraitItemNode i, string derefChainBorrow) {
       ArgIsInstantiationOf<MethodCallCand, MethodCallReceiverIsInstantiationOfInput>::argIsNotInstanceOf(MkMethodCallCand(this,
           derefChainBorrow), i, _)
+      or
+      IsInstantiationOf<MethodCallCallExpr, TypeMentionTypeTree, MethodCallCallExprIsInstantiationOfInput>::isNotInstantiationOf(this,
+        i, _) and
+      derefChainBorrow = ";"
     }
 
     /**
@@ -1226,6 +1241,8 @@ private module MethodResolution {
         // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
           methodCallNonBlanketCandidate(this, _, i, _, strippedTypePath, strippedType)
+          or
+          CallExprImpl::getResolvedFunction(this) = i.(ImplItemNode).getASuccessor(_)
         |
           this.hasIncompatibleTarget(i, derefChainBorrow)
         )
@@ -1247,6 +1264,8 @@ private module MethodResolution {
         // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
           methodCallNonBlanketCandidate(this, _, i, _, strippedTypePath, strippedType)
+          or
+          CallExprImpl::getResolvedFunction(this) = i.(ImplItemNode).getASuccessor(_)
         |
           this.hasIncompatibleTarget(i, derefChainBorrow)
         )
@@ -1405,10 +1424,9 @@ private module MethodResolution {
     override predicate supportsAutoDerefAndBorrow() { none() }
   }
 
-  bindingset[item, name]
-  pragma[inline_late]
-  private Method getMethodSuccessor(ItemNode item, string name, int arity) {
-    result = item.getASuccessor(name) and
+  pragma[nomagic]
+  private Method getMethodSuccessor(ImplOrTraitItemNode i, string name, int arity) {
+    result = i.getASuccessor(name) and
     arity = result.getParamList().getNumberOfParams()
   }
 
@@ -1475,16 +1493,22 @@ private module MethodResolution {
     }
 
     pragma[nomagic]
-    private Method resolveCallTargetCand(ImplOrTraitItemNode i) {
-      exists(string name |
+    private predicate argIsInstanceOf(ImplOrTraitItemNode i, string name, int arity) {
+      (
         ArgIsInstantiationOf<MethodCallCand, MethodCallReceiverIsInstantiationOfInput>::argIsInstanceOf(this,
           i, _)
         or
         IsInstantiationOf<MethodCallCallExpr, TypeMentionTypeTree, MethodCallCallExprIsInstantiationOfInput>::isInstantiationOf(mc_,
           i, _)
-      |
-        mc_.hasNameAndArity(name, _) and
-        result = getMethodSuccessor(i, name, _)
+      ) and
+      mc_.hasNameAndArity(name, arity)
+    }
+
+    pragma[nomagic]
+    private Method resolveCallTargetCand(ImplOrTraitItemNode i) {
+      exists(string name, int arity |
+        this.argIsInstanceOf(i, name, arity) and
+        result = getMethodSuccessor(i, name, arity)
       )
     }
 
@@ -1881,13 +1905,21 @@ private module AssocFunctionResolution {
     )
   }
 
+  private Type getTypeAt(AssocFunctionCall fc, FunctionTypePosition pos, TypePath path) {
+    result = inferType(fc.getArg(pos.asPositional()), path)
+    or
+    pos.isReturn() and
+    result = inferType(fc, path)
+  }
+
   pragma[nomagic]
   private predicate functionCallBlanketCandidate(
     AssocFunctionCall fc, AssocFunction f, FunctionTypePosition pos, TypePath blanketPath,
     TypeParam blanketTypeParam
   ) {
     exists(string name, int arity, ImplItemNode impl, Trait trait, FunctionType t |
       fc.hasNameAndArity(name, arity) and
+      exists(getTypeAt(fc, pos, blanketPath)) and
       functionInfoBlanketRelevantPos(f, name, arity, impl, trait, pos, t, blanketPath,
         blanketTypeParam) and
       TraitIsVisible<blanketCallTraitCandidate/2>::traitIsVisible(fc, trait)
@@ -1907,12 +1939,7 @@ private module AssocFunctionResolution {
 
     Location getLocation() { result = fc.getLocation() }
 
-    Type getTypeAt(TypePath path) {
-      result = inferType(fc.getArg(pos.asPositional()), path)
-      or
-      pos.isReturn() and
-      result = inferType(fc, path)
-    }
+    Type getTypeAt(TypePath path) { result = getTypeAt(fc, pos, path) }
 
     string toString() { result = fc.toString() + " [arg " + pos + "]" }
   }
@@ -3048,12 +3075,12 @@ import Cached
 Type inferType(AstNode n) { result = inferType(n, TypePath::nil()) }
 
 /** Provides predicates for debugging the type inference implementation. */
-private module Debug {
+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("%/blanket_impl.rs") and
-      startline = 96
+      filepath.matches("%/sqlx.rs") and
+      startline = 246
     )
   }
 

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

@@ -15,8 +15,7 @@ private import codeql.rust.internal.TypeInference
  * `traitBound` is the first non-trivial trait bound of `tp`.
  */
 pragma[nomagic]
-private predicate blanketImplementationTraitBound(TypeParamItemNode tp, Trait traitBound) {
-  tp = any(ImplItemNode impl).getBlanketImplementationTypeParam() and
+private predicate hasFirstNonTrivialTraitBound(TypeParamItemNode tp, Trait traitBound) {
   traitBound =
     min(Trait trait, int i |
       trait = tp.resolveBound(i) and
@@ -50,7 +49,8 @@ module SatisfiesBlanketConstraint<
 {
   private newtype TArgumentTypeAndBlanketOffset =
     MkArgumentTypeAndBlanketOffset(ArgumentType at, TypePath blanketPath) {
-      Input::hasBlanketCandidate(at, _, blanketPath, _)
+      Input::hasBlanketCandidate(at, _, blanketPath, _) and
+      exists(at.getTypeAt(blanketPath))
     }
 
   private class ArgumentTypeAndBlanketOffset extends MkArgumentTypeAndBlanketOffset {
@@ -76,7 +76,7 @@ module SatisfiesBlanketConstraint<
       exists(ArgumentType at, TypePath blanketPath, TypeParam blanketTypeParam |
         ato = MkArgumentTypeAndBlanketOffset(at, blanketPath) and
         Input::hasBlanketCandidate(at, f, blanketPath, blanketTypeParam) and
-        blanketImplementationTraitBound(blanketTypeParam, traitBound)
+        hasFirstNonTrivialTraitBound(blanketTypeParam, traitBound)
       )
     }
 
@@ -90,7 +90,7 @@ module SatisfiesBlanketConstraint<
 
   /**
    * Holds if the argument type `at` satisfies the first non-trivial blanket
-   * constraint of the function `f`.
+   * constraint of the function `f`, if such a constraint exists.
    */
   pragma[nomagic]
   predicate satisfiesBlanketConstraint(ArgumentType at, Function f) {
@@ -100,5 +100,11 @@ module SatisfiesBlanketConstraint<
       SatisfiesConstraint<ArgumentTypeAndBlanketOffset, SatisfiesBlanketConstraintInput>::satisfiesConstraintType(ato,
         TTrait(traitBound), _, _)
     )
+    or
+    exists(TypePath blanketPath, TypeParam blanketTypeParam |
+      Input::hasBlanketCandidate(at, f, blanketPath, blanketTypeParam) and
+      exists(at.getTypeAt(blanketPath)) and
+      not hasFirstNonTrivialTraitBound(blanketTypeParam, _)
+    )
   }
 }

rust/ql/test/library-tests/type-inference/type-inference.expected

@@ -7102,3 +7102,4 @@ inferType
 | pattern_matching.rs:827:5:827:7 | f(...) |  | {EXTERNAL LOCATION} | Option |
 | pattern_matching.rs:827:5:827:7 | f(...) | T | file://:0:0:0:0 | () |
 testFailures
+| main.rs:2566:20:2566:32 | ... .into() | Fixed missing result: target=into |