foo

Author: hvitved

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

@@ -1176,6 +1176,114 @@ private Type substituteLookupTraits(Type t) {
  * [1]: https://doc.rust-lang.org/reference/expressions/method-call-expr.html#r-expr.method.candidate-receivers
  */
 private module MethodCallResolution {
+  /**
+   * Provides logic for checking receiver types against constraints of
+   * [blanket implementations][1].
+   *
+   * [1]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
+   */
+  module BlanketImplementation {
+    /**
+     * Holds if `tp` is the type parameter of a blanket implementation and
+     * `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
+      traitBound =
+        min(Trait trait, int i |
+          trait = tp.resolveBound(i) and
+          // Exclude traits that are known to not narrow things down very much.
+          not trait.getName().getText() =
+            [
+              "Sized", "Clone",
+              // The auto traits
+              "Send", "Sync", "Unpin", "UnwindSafe", "RefUnwindSafe"
+            ]
+        |
+          trait order by i
+        )
+    }
+
+    signature module SatisfiesBlanketConstraintInputSig<HasTypeTreeSig ReceiverType> {
+      /**
+       * Holds if a method call with receiver type `rt` may potentially target
+       * `m`, which is defined in a blanket implementation with type parameter
+       * `blanketTypeParam`.
+       *
+       * `blanketPath` points to the type `blanketTypeParam` inside the type of
+       * `m`'s `self` parameter.
+       */
+      predicate hasBlanketCandidate(
+        ReceiverType rt, Function m, TypePath blanketPath, TypeParam blanketTypeParam
+      );
+    }
+
+    module SatisfiesBlanketConstraint<
+      HasTypeTreeSig ReceiverType, SatisfiesBlanketConstraintInputSig<ReceiverType> Input>
+    {
+      private newtype TReceiverTypeAndBlanketOffset =
+        MkReceiverTypeAndBlanketOffset(ReceiverType rt, TypePath blanketPath) {
+          Input::hasBlanketCandidate(rt, _, blanketPath, _)
+        }
+
+      private class ReceiverTypeAndBlanketOffset extends MkReceiverTypeAndBlanketOffset {
+        ReceiverType rt;
+        TypePath blanketPath;
+
+        ReceiverTypeAndBlanketOffset() { this = MkReceiverTypeAndBlanketOffset(rt, blanketPath) }
+
+        ReceiverType getReceiverType() { result = rt }
+
+        TypePath getBlanketPath() { result = blanketPath }
+
+        Location getLocation() { result = rt.getLocation() }
+
+        Type getTypeAt(TypePath path) { result = rt.getTypeAt(blanketPath.appendInverse(path)) }
+
+        string toString() {
+          result = rt.toString() + " [blanket at " + blanketPath.toString() + "]"
+        }
+      }
+
+      private module SatisfiesBlanketConstraintInput implements
+        SatisfiesConstraintInputSig<ReceiverTypeAndBlanketOffset>
+      {
+        pragma[nomagic]
+        additional predicate relevantConstraint(
+          ReceiverTypeAndBlanketOffset rto, Function m, Trait traitBound
+        ) {
+          exists(ReceiverType rt, TypePath blanketPath, TypeParam blanketTypeParam |
+            rto = MkReceiverTypeAndBlanketOffset(rt, blanketPath) and
+            Input::hasBlanketCandidate(rt, m, blanketPath, blanketTypeParam) and
+            blanketImplementationTraitBound(blanketTypeParam, traitBound)
+          )
+        }
+
+        pragma[nomagic]
+        predicate relevantConstraint(ReceiverTypeAndBlanketOffset rto, Type constraint) {
+          relevantConstraint(rto, _, constraint.(TraitType).getTrait())
+        }
+
+        predicate useUniversalConditions() { none() }
+      }
+
+      /**
+       * Holds if the receiver type `rt` satisfies the first non-trivial blanket
+       * constraint of the method `m`.
+       */
+      pragma[nomagic]
+      predicate satisfiesBlanketConstraint(ReceiverType rt, Function m) {
+        exists(ReceiverTypeAndBlanketOffset rto, Trait traitBound |
+          rto = MkReceiverTypeAndBlanketOffset(rt, _) and
+          SatisfiesBlanketConstraintInput::relevantConstraint(rto, m, traitBound) and
+          SatisfiesConstraint<ReceiverTypeAndBlanketOffset, SatisfiesBlanketConstraintInput>::satisfiesConstraintType(rto,
+            TTrait(traitBound), _, _)
+        )
+      }
+    }
+  }
+
   /**
    * Holds if `root` is a valid complex [`self` root type][1], with type
    * parameter `tp`.
@@ -1684,86 +1792,18 @@ private module MethodCallResolution {
     Location getLocation() { result = mc_.getLocation() }
   }
 
-  private newtype TMethodCallCandAndBlanketOffset =
-    MkMethodCallCandAndBlanketOffset(MethodCallCand mcc, TypePath blanketPath) {
-      exists(MethodCall mc, string name, int arity, TypeParam blanketTypeParam |
-        mcc.hasInfo(mc, _, _, name, arity) and
-        methodCallBlanketCandidate(mc, _, _, _, blanketPath, blanketTypeParam)
-      )
-    }
-
-  private class MethodCallCandAndBlanketOffset extends MkMethodCallCandAndBlanketOffset {
-    MethodCallCand mcc_;
-    TypePath blanketPath;
-
-    MethodCallCandAndBlanketOffset() { this = MkMethodCallCandAndBlanketOffset(mcc_, blanketPath) }
-
-    MethodCallCand getMethodCallCand() { result = mcc_ }
-
-    TypePath getBlanketPath() { result = blanketPath }
-
-    Location getLocation() { result = mcc_.getLocation() }
-
-    Type getTypeAt(TypePath path) { result = mcc_.getTypeAt(blanketPath.appendInverse(path)) }
-
-    string toString() { result = mcc_.toString() + " (blanket at " + blanketPath.toString() + ")" }
-  }
-
   private module SatisfiesBlanketConstraintInput implements
-    SatisfiesConstraintInputSig<MethodCallCandAndBlanketOffset>
+    BlanketImplementation::SatisfiesBlanketConstraintInputSig<MethodCallCand>
   {
-    /**
-     * Holds if `impl` is a blanket implementation for a type parameter and
-     * `traitBound` is the first non-trivial trait bound of that type parameter.
-     */
     pragma[nomagic]
-    private predicate blanketImplementationTraitBound(TypeParamItemNode tp, Trait traitBound) {
-      tp = any(ImplItemNode impl).getBlanketImplementationTypeParam() and
-      traitBound =
-        min(Trait trait, int i |
-          trait = tp.resolveBound(i) and
-          // Exclude traits that are known to not narrow things down very much.
-          not trait.getName().getText() =
-            [
-              "Sized", "Clone",
-              // The auto traits
-              "Send", "Sync", "Unpin", "UnwindSafe", "RefUnwindSafe"
-            ]
-        |
-          trait order by i
-        )
-    }
-
-    pragma[nomagic]
-    additional predicate relevantConstraint(
-      MethodCallCandAndBlanketOffset mcco, Function m, Trait traitBound
+    predicate hasBlanketCandidate(
+      MethodCallCand mcc, Function m, TypePath blanketPath, TypeParam blanketTypeParam
     ) {
-      exists(
-        MethodCallCand mcc, MethodCall mc, string name, int arity, TypePath blanketPath,
-        TypeParam blanketTypeParam
-      |
-        mcco = MkMethodCallCandAndBlanketOffset(mcc, blanketPath) and
+      exists(MethodCall mc, string name, int arity |
         mcc.hasInfo(mc, _, _, name, arity) and
-        methodCallBlanketCandidate(mc, m, _, _, blanketPath, blanketTypeParam) and
-        blanketImplementationTraitBound(blanketTypeParam, traitBound)
+        methodCallBlanketCandidate(mc, m, _, _, blanketPath, blanketTypeParam)
       )
     }
-
-    pragma[nomagic]
-    predicate relevantConstraint(MethodCallCandAndBlanketOffset mcco, Type constraint) {
-      relevantConstraint(mcco, _, constraint.(TraitType).getTrait())
-    }
-
-    predicate useUniversalConditions() { none() }
-  }
-
-  private predicate hasBlanketImpl(MethodCallCand mcc, Function f) {
-    exists(MethodCallCandAndBlanketOffset mcco, Trait traitBound |
-      mcco = MkMethodCallCandAndBlanketOffset(mcc, _) and
-      SatisfiesBlanketConstraintInput::relevantConstraint(mcco, f, traitBound) and
-      SatisfiesConstraint<MethodCallCandAndBlanketOffset, SatisfiesBlanketConstraintInput>::satisfiesConstraintType(mcco,
-        TTrait(traitBound), _, _)
-    )
   }
 
   /**
@@ -1786,7 +1826,8 @@ private module MethodCallResolution {
         methodCallNonBlanketCandidate(mc, m, abs, constraint, strippedTypePath, strippedType)
         or
         methodCallBlanketCandidate(mc, m, abs, constraint, _, _) and
-        hasBlanketImpl(mcc, m)
+        BlanketImplementation::SatisfiesBlanketConstraint<MethodCallCand, SatisfiesBlanketConstraintInput>::satisfiesBlanketConstraint(mcc,
+          m)
       )
     }