WIP

Author: paldepind

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

@@ -933,15 +933,38 @@ class TypeParamItemNode extends TypeItemNode instanceof TypeParam {
   }
 
   pragma[nomagic]
-  Path getABoundPath() {
-    exists(TypeBoundList tbl | result = tbl.getABound().getTypeRepr().(PathTypeRepr).getPath() |
-      tbl = super.getTypeBoundList()
+  TypeBound getBound(int index) {
+    result = super.getTypeBoundList().getBound(index)
+    or
+    exists(int offset |
+      offset = super.getTypeBoundList().getNumberOfBounds()
       or
-      tbl = this.getAWherePred().getTypeBoundList()
+      not super.hasTypeBoundList() and
+      offset = 0
+    |
+      result = this.getAWherePred().getTypeBoundList().getBound(index - offset)
     )
   }
 
   pragma[nomagic]
+  Path getBoundPath(int index) {
+    result = this.getBound(index).getTypeRepr().(PathTypeRepr).getPath()
+  }
+
+  Path getABoundPath() { result = this.getBoundPath(_) }
+
+  pragma[nomagic]
+  ItemNode resolveBound(int index) {
+    result =
+      rank[index + 1](int i, ItemNode item |
+        item = resolvePath(this.getBoundPath(i))
+      |
+        item order by i
+      )
+  }
+
+  private predicate noFirst2() { not exists(this.resolveBound(0)) and exists(this.resolveBound(1)) }
+
   ItemNode resolveABound() { result = resolvePath(this.getABoundPath()) }
 
   /**

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

@@ -1512,6 +1512,10 @@ private predicate methodCandidateTrait(Type type, Trait trait, string name, int
   methodCandidate(type, name, arity, impl)
 }
 
+/**
+ * Holds if `mc` has `rootType` as the root type of the reciever and the target
+ * method is named `name` and has arity `arity`
+ */
 pragma[nomagic]
 private predicate isMethodCall(MethodCall mc, Type rootType, string name, int arity) {
   rootType = mc.getTypeAt(TypePath::nil()) and
@@ -1710,6 +1714,91 @@ private predicate methodCallHasImplCandidate(MethodCall mc, Impl impl) {
   else any()
 }
 
+private module BlanketImplementation {
+  /**
+   * Holds if `impl` is a blanket implementation, that is, an implementation of a
+   * trait for a type parameter.
+   */
+  private TypeParamItemNode getBlanketImplementationTypeParam(Impl impl) {
+    result = impl.(ImplItemNode).resolveSelfTy() and
+    result = impl.getGenericParamList().getAGenericParam() and
+    not exists(impl.getAttributeMacroExpansion())
+  }
+
+  /**
+   * Holds if `impl` is a blanket implementation for a type parameter and the type
+   * parameter must implement `trait`.
+   */
+  private predicate blanketImplementationTraitBound(Impl impl, Trait t) {
+    t =
+      rank[1](Trait trait, int i |
+        trait = getBlanketImplementationTypeParam(impl).resolveBound(i) and
+        not trait.getName().getText() = ["Sized", "Fn", "FnOnce", "FnMut"]
+      |
+        trait order by i
+      )
+  }
+
+  private predicate blanketImplementationWithoutBound(Impl impl) {
+    not exists(impl.getAttributeMacroExpansion()) and
+    exists(TypeParam gp |
+      gp = impl.getGenericParamList().getAGenericParam() and
+      gp = impl.(ImplItemNode).resolveSelfTy() and
+      not exists(gp.(TypeParamItemNode).getABoundPath())
+    )
+  }
+
+  private predicate test(Impl impl, ItemNode resolved) {
+    exists(TypeParamItemNode tp |
+      tp = getBlanketImplementationTypeParam(impl) and
+      not blanketImplementationTraitBound(impl, _) and
+      not blanketImplementationWithoutBound(impl) and
+      resolved = resolvePath(tp.getBoundPath(0))
+    )
+  }
+
+  private predicate blanketImplementationMethod(
+    Impl impl, Trait trait, string name, int arity, Function f
+  ) {
+    f = impl.(ImplItemNode).getASuccessor(name) and
+    blanketImplementationTraitBound(impl, trait) and
+    f.getParamList().hasSelfParam() and
+    arity = f.getParamList().getNumberOfParams() and
+    // Make this stronger and document
+    not trait.(TraitItemNode).getASuccessor(name) = f
+  }
+
+  predicate methodCallMatchesBlanketImpl(MethodCall mc, Type t, Impl impl, Trait trait, Function f) {
+    exists(string name, int arity |
+      isMethodCall(mc, t, name, arity) and
+      blanketImplementationMethod(impl, trait, name, arity, f)
+    )
+  }
+
+  module SatisfiesConstraintInput implements SatisfiesConstraintInputSig<MethodCall> {
+    pragma[nomagic]
+    predicate relevantConstraint(MethodCall mc, Type constraint) {
+      methodCallMatchesBlanketImpl(mc, _, _, constraint.(TraitType).getTrait(), _)
+    }
+  }
+
+  predicate debugSatisfiesConstraintType(MethodCall mc, Trait trait, TypePath path, Type ty) {
+    SatisfiesConstraint<MethodCall, SatisfiesConstraintInput>::satisfiesConstraintType(mc,
+      TTrait(trait), path, ty)
+  }
+
+  predicate getBlanketImpl(MethodCall mc, Type t, Impl impl, Trait trait, Function f) {
+    SatisfiesConstraint<MethodCall, SatisfiesConstraintInput>::satisfiesConstraintType(mc,
+      TTrait(trait), _, _) and
+    methodCallMatchesBlanketImpl(mc, t, impl, trait, f)
+  }
+
+  pragma[nomagic]
+  Function getMethodFromBlanketImpl(MethodCall mc) {
+    BlanketImplementation::getBlanketImpl(mc, _, _, _, result)
+  }
+}
+
 /** Gets a method from an `impl` block that matches the method call `mc`. */
 pragma[nomagic]
 private Function getMethodFromImpl(MethodCall mc) {
@@ -1745,6 +1834,8 @@ private Function resolveMethodCallTarget(MethodCall mc) {
   // The method comes from an `impl` block targeting the type of the receiver.
   result = getMethodFromImpl(mc)
   or
+  result = BlanketImplementation::getMethodFromBlanketImpl(mc)
+  or
   // The type of the receiver is a type parameter and the method comes from a
   // trait bound on the type parameter.
   result = getTypeParameterMethod(mc.getTypeAt(TypePath::nil()), mc.getMethodName())