wip3

Author: hvitved

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

@@ -891,108 +891,6 @@ private module FunctionOverloading {
   }
 }
 
-/**
- * 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
- */
-private 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) }
-
-      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), _, _)
-      )
-    }
-  }
-}
-
 private Trait getALookupTrait(Type t) {
   result = t.(TypeParamTypeParameter).getTypeParam().(TypeParamItemNode).resolveABound()
   or
@@ -1657,18 +1555,105 @@ private module MethodCallResolution {
     Location getLocation() { result = mc_.getLocation() }
   }
 
-  private module SatisfiesBlanketConstraintInput implements
-    BlanketImplementation::SatisfiesBlanketConstraintInputSig<MethodCallCand>
-  {
+  /**
+   * 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
+   */
+  private 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]
-    predicate hasBlanketCandidate(
+    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
+        )
+    }
+
+    /**
+     * Holds if `mcc` 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.
+     */
+    pragma[nomagic]
+    private predicate hasBlanketCandidate(
       MethodCallCand mcc, Function m, TypePath blanketPath, TypeParam blanketTypeParam
     ) {
       exists(MethodCall mc, string name, int arity |
         mcc.hasSignature(mc, _, _, name, arity) and
         methodCallBlanketCandidate(mc, m, _, _, blanketPath, blanketTypeParam)
       )
     }
+
+    private newtype TMethodCallCandAndBlanketOffset =
+      MkMethodCallCandAndBlanketOffset(MethodCallCand mcc, TypePath blanketPath) {
+        hasBlanketCandidate(mcc, _, blanketPath, _)
+      }
+
+    private class MethodCallCandAndBlanketOffset extends MkMethodCallCandAndBlanketOffset {
+      MethodCallCand mcc;
+      TypePath blanketPath;
+
+      MethodCallCandAndBlanketOffset() { this = MkMethodCallCandAndBlanketOffset(mcc, 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>
+    {
+      pragma[nomagic]
+      additional predicate relevantConstraint(
+        MethodCallCandAndBlanketOffset mccbo, Function m, Trait traitBound
+      ) {
+        exists(MethodCallCand mcc, TypePath blanketPath, TypeParam blanketTypeParam |
+          mccbo = MkMethodCallCandAndBlanketOffset(mcc, blanketPath) and
+          hasBlanketCandidate(mcc, m, blanketPath, blanketTypeParam) and
+          blanketImplementationTraitBound(blanketTypeParam, traitBound)
+        )
+      }
+
+      pragma[nomagic]
+      predicate relevantConstraint(MethodCallCandAndBlanketOffset mccbo, Type constraint) {
+        relevantConstraint(mccbo, _, constraint.(TraitType).getTrait())
+      }
+
+      predicate useUniversalConditions() { none() }
+    }
+
+    /**
+     * Holds if the receiver type of `mcc` satisfies the first non-trivial blanket
+     * constraint of the method `m`.
+     */
+    pragma[nomagic]
+    predicate satisfiesBlanketConstraint(MethodCallCand mcc, Function m) {
+      exists(MethodCallCandAndBlanketOffset mccbo, Trait traitBound |
+        mccbo = MkMethodCallCandAndBlanketOffset(mcc, _) and
+        SatisfiesBlanketConstraintInput::relevantConstraint(mccbo, m, traitBound) and
+        SatisfiesConstraint<MethodCallCandAndBlanketOffset, SatisfiesBlanketConstraintInput>::satisfiesConstraintType(mccbo,
+          TTrait(traitBound), _, _)
+      )
+    }
   }
 
   /**
@@ -1691,8 +1676,7 @@ private module MethodCallResolution {
         methodCallNonBlanketCandidate(mc, m, abs, constraint, strippedTypePath, strippedType)
         or
         methodCallBlanketCandidate(mc, m, abs, constraint, _, _) and
-        BlanketImplementation::SatisfiesBlanketConstraint<MethodCallCand, SatisfiesBlanketConstraintInput>::satisfiesBlanketConstraint(mcc,
-          m)
+        BlanketImplementation::satisfiesBlanketConstraint(mcc, m)
       )
     }