rename

Author: hvitved

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

@@ -712,8 +712,10 @@ final class ImplItemNode extends ImplOrTraitItemNode instanceof Impl {
   TypeParamItemNode getBlanketImplementationTypeParam() { result = this.resolveSelfTy() }
 
   /**
-   * Holds if this impl block is a blanket implementation. That is, the
+   * Holds if this impl block is a [blanket implementation][1]. That is, the
    * implementation targets a generic parameter of the impl block.
+   *
+   * [1]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
    */
   predicate isBlanketImplementation() { exists(this.getBlanketImplementationTypeParam()) }
 

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

@@ -1226,7 +1226,9 @@ private module MethodCallResolution {
    * `i`, and the type of the `self` parameter is `selfType`.
    *
    * `strippedTypePath` points to the type `strippedType` inside `selfType`,
-   * which is the (possibly complex-stripped) root type of `selfType`.
+   * which is the (possibly complex-stripped) root type of `selfType`. For example,
+   * if `m` has a `&self` parameter, then `strippedTypePath` is `TRefTypeParameter()`
+   * and `strippedType` is the type inside the reference.
    */
   pragma[nomagic]
   predicate methodInfo(
@@ -1252,11 +1254,12 @@ private module MethodCallResolution {
   }
 
   /**
-   * Same as `methodInfo`, but allows for any `strippedType` when the
-   * corresponding type inside `m` is a type parameter.
+   * Same as `methodInfo`, but restricted to non-blanket implementations, and
+   * allowing for any `strippedType` when the corresponding type inside `m` is
+   * a type parameter.
    */
   pragma[inline]
-  predicate methodInfoNonBlanketMatch(
+  predicate methodInfoNonBlanket(
     Function m, string name, int arity, ImplOrTraitItemNode i, FunctionType selfType,
     TypePath strippedTypePath, Type strippedType
   ) {
@@ -1268,11 +1271,17 @@ private module MethodCallResolution {
   }
 
   /**
-   * Same as `methodInfo`, but allows for any `strippedType` when the
-   * corresponding type inside `m` is a type parameter.
+   * Holds if method `m` with the name `name` and the arity `arity` exists in
+   * [blanket implementation][1] `i` and the type of the `self` parameter is
+   * `selfType`.
+   *
+   * `blanketPath` points to the type `blanketTypeParam` inside `selfType`, which
+   * is the type parameter used in the blanket implementation.
+   *
+   * [1]: https://doc.rust-lang.org/book/ch10-02-traits.html#using-trait-bounds-to-conditionally-implement-methods
    */
   pragma[nomagic]
-  predicate methodInfoBlanketMatch(
+  predicate methodInfoBlanket(
     Function m, string name, int arity, ImplItemNode i, FunctionType selfType, TypePath blanketPath,
     TypeParam blanketTypeParam
   ) {
@@ -1327,7 +1336,7 @@ private module MethodCallResolution {
   ) {
     exists(string name, int arity |
       mc.hasNameAndArity(name, arity) and
-      methodInfoNonBlanketMatch(m, name, arity, i, self, strippedTypePath, strippedType)
+      methodInfoNonBlanket(m, name, arity, i, self, strippedTypePath, strippedType)
     |
       i =
         any(Impl impl |
@@ -1344,11 +1353,11 @@ private module MethodCallResolution {
   }
 
   /**
-   * Holds if method call `mc` may target a method in `i` with `self` parameter having
-   * type `selfType`.
+   * Holds if method call `mc` may target a method in blanket implementation `i`
+   * with `self` parameter having type `selfType`.
    *
-   * `strippedTypePath` points to the type `strippedType` inside `selfType`,
-   * which is the (possibly complex-stripped) root type of `selfType`.
+   * `blanketPath` points to the type `blanketTypeParam` inside `selfType`, which
+   * is the type parameter used in the blanket implementation.
    *
    * This predicate only checks for matching method names and arities, and whether
    * the trait being implemented by `i` (when `i` is not a trait itself) is visible
@@ -1362,7 +1371,7 @@ private module MethodCallResolution {
   ) {
     exists(string name, int arity |
       mc.hasNameAndArity(name, arity) and
-      methodInfoBlanketMatch(m, name, arity, i, self, blanketPath, blanketTypeParam)
+      methodInfoBlanket(m, name, arity, i, self, blanketPath, blanketTypeParam)
     |
       methodCallVisibleImplTraitCandidate(mc, i)
       or
@@ -1450,6 +1459,7 @@ private module MethodCallResolution {
         not derefChain.matches("%.ref") and // no need to try a borrow if the last thing we did was a deref
         strippedType = this.getComplexstrippedType(strippedTypePath, derefChainBorrow)
       |
+        // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
           methodCallNonBlanketCandidate(this, _, i, _, strippedTypePath, strippedType)
         |
@@ -1469,6 +1479,7 @@ private module MethodCallResolution {
         this.hasNoCompatibleTargetNoBorrow(derefChain) and
         strippedType = this.getComplexstrippedType(strippedTypePath, derefChainBorrow)
       |
+        // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
           methodCallNonBlanketCandidate(this, _, i, _, strippedTypePath, strippedType)
         |
@@ -1516,7 +1527,8 @@ private module MethodCallResolution {
      */
     pragma[nomagic]
     Function resolveCallTarget(string derefChainBorrow) {
-      exists(MethodCallCand mcc | mcc = MkMethodCallCand(this, derefChainBorrow) |
+      exists(MethodCallCand mcc |
+        mcc = MkMethodCallCand(this, derefChainBorrow) and
         result = mcc.resolveCallTarget()
       )
     }
@@ -1610,7 +1622,7 @@ private module MethodCallResolution {
       exists(TypePath strippedTypePath, Type strippedType, string name, int arity |
         this.hasInfo(_, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
-          methodInfoNonBlanketMatch(_, name, arity, i, _, strippedTypePath, strippedType) and
+          methodInfoNonBlanket(_, name, arity, i, _, strippedTypePath, strippedType) and
           not i.hasTrait()
         |
           this.hasIncompatibleInherentTarget(i)
@@ -2413,12 +2425,12 @@ private module OperationResolution {
   {
     // todo
     bindingset[strippedTypePath]
-    private predicate methodInfoNonBlanketMatch(
+    private predicate methodInfoNonBlanket(
       TypeAbstraction abs, FunctionType constraint, Trait trait, string name, int arity,
       TypePath strippedTypePath, Type strippedType
     ) {
-      MethodCallResolution::methodInfoNonBlanketMatch(_, name, arity, abs, constraint,
-        strippedTypePath, strippedType) and
+      MethodCallResolution::methodInfoNonBlanket(_, name, arity, abs, constraint, strippedTypePath,
+        strippedType) and
       not abs.(ImplItemNode).isBlanketImplementation() and
       (
         trait = abs.(ImplItemNode).resolveTraitTy()
@@ -2431,8 +2443,7 @@ private module OperationResolution {
     predicate potentialInstantiationOf(Op op, TypeAbstraction abs, FunctionType constraint) {
       exists(Trait trait, string name, int arity, TypePath strippedTypePath, Type strippedType |
         op.hasInfo(strippedTypePath, strippedType, trait, name, arity) and
-        methodInfoNonBlanketMatch(abs, constraint, trait, name, arity, strippedTypePath,
-          strippedType)
+        methodInfoNonBlanket(abs, constraint, trait, name, arity, strippedTypePath, strippedType)
       )
     }