wip

Author: hvitved

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

@@ -1262,7 +1262,7 @@ private predicate assocFunctionInfo(
  * is the type parameter used in the blanket implementation.
  */
 pragma[nomagic]
-private predicate functionInfoBlanketLike(
+private predicate assocFunctionInfoBlanketLike(
   Function f, string name, int arity, ImplItemNode impl, Trait trait, FunctionPosition pos,
   AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
 ) {
@@ -1366,85 +1366,86 @@ private class BorrowKind extends TBorrowKind {
  */
 private module MethodResolution {
   /**
-   * Holds if method `m` with the name `name` and the arity `arity` exists in
+   * Holds if function `f` with the name `name` and the arity `arity` exists in
    * `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`. For example,
-   * if `m` has a `&self` parameter, then `strippedTypePath` is `getRefSharedTypeParameter()`
+   * if `f` has a `&self` parameter, then `strippedTypePath` is `getRefSharedTypeParameter()`
    * and `strippedType` is the type inside the reference.
    */
   pragma[nomagic]
-  private predicate methodInfo(
-    Method m, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
+  private predicate assocFunctionInfo(
+    Function f, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
     AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType
   ) {
-    assocFunctionInfo(m, name, arity, i, selfPos, selfType) and
+    assocFunctionInfo(f, name, arity, i, selfPos, selfType) and
     strippedType = selfType.getTypeAt(strippedTypePath) and
     isComplexRootStripped(strippedTypePath, strippedType) and
     selfPos.isSelfOrTypeQualifier()
   }
 
   pragma[nomagic]
-  private predicate methodInfoTypeParam(
-    Method m, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
+  private predicate assocFunctionInfoTypeParam(
+    Function f, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
     AssocFunctionType selfType, TypePath strippedTypePath, TypeParam tp
   ) {
-    methodInfo(m, name, arity, selfPos, i, selfType, strippedTypePath, TTypeParamTypeParameter(tp))
+    assocFunctionInfo(f, name, arity, selfPos, i, selfType, strippedTypePath,
+      TTypeParamTypeParameter(tp))
   }
 
   /**
-   * Same as `methodInfo`, but restricted to non-blanket implementations, and
-   * allowing for any `strippedType` when the corresponding type inside `m` is
+   * Same as `assocFunctionInfo`, but restricted to non-blanket implementations, and
+   * allowing for any `strippedType` when the corresponding type inside `f` is
    * a type parameter.
    */
   pragma[inline]
-  private predicate methodInfoNonBlanket(
-    Method m, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
+  private predicate assocFunctionInfoNonBlanket(
+    Function f, string name, int arity, FunctionPosition selfPos, ImplOrTraitItemNode i,
     AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType
   ) {
     (
-      methodInfo(m, name, arity, selfPos, i, selfType, strippedTypePath, strippedType) or
-      methodInfoTypeParam(m, name, arity, selfPos, i, selfType, strippedTypePath, _)
+      assocFunctionInfo(f, name, arity, selfPos, i, selfType, strippedTypePath, strippedType) or
+      assocFunctionInfoTypeParam(f, name, arity, selfPos, i, selfType, strippedTypePath, _)
     ) and
     not BlanketImplementation::isBlanketLike(i, _, _)
   }
 
   /**
-   * Holds if method `m` with the name `name` and the arity `arity` exists in
+   * Holds if function `f` with the name `name` and the arity `arity` exists in
    * blanket (like) implementation `impl` of `trait`, 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.
    */
   pragma[nomagic]
-  private predicate methodInfoBlanketLike(
-    Method m, string name, int arity, FunctionPosition selfPos, ImplItemNode impl, Trait trait,
+  private predicate assocFunctionSelfInfoBlanketLike(
+    Function f, string name, int arity, FunctionPosition selfPos, ImplItemNode impl, Trait trait,
     AssocFunctionType selfType, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
-    functionInfoBlanketLike(m, name, arity, impl, trait, selfPos, selfType, blanketPath,
+    assocFunctionInfoBlanketLike(f, name, arity, impl, trait, selfPos, selfType, blanketPath,
       blanketTypeParam) and
     selfPos.isSelfOrTypeQualifier()
   }
 
   pragma[nomagic]
-  private predicate methodTraitInfo(string name, int arity, Trait trait) {
+  private predicate assocFunctionTraitInfo(string name, int arity, Trait trait) {
     exists(ImplItemNode i |
-      methodInfo(_, name, arity, _, i, _, _, _) and
+      assocFunctionInfo(_, name, arity, _, i, _, _, _) and
       trait = i.resolveTraitTy()
     )
     or
-    methodInfo(_, name, arity, _, trait, _, _, _)
+    assocFunctionInfo(_, name, arity, _, trait, _, _, _)
   }
 
   pragma[nomagic]
-  private predicate methodCallTraitCandidate(Element mc, Trait trait) {
+  private predicate assocFunctionCallTraitCandidate(Element mc, Trait trait) {
     mc =
       any(MethodCall mc0 |
         exists(string name, int arity |
           mc0.hasNameAndArity(name, arity) and
-          methodTraitInfo(name, arity, trait)
+          assocFunctionTraitInfo(name, arity, trait)
         |
           not mc0.hasTrait()
           or
@@ -1453,7 +1454,7 @@ private module MethodResolution {
       )
   }
 
-  private module MethodTraitIsVisible = TraitIsVisible<methodCallTraitCandidate/2>;
+  private module MethodTraitIsVisible = TraitIsVisible<assocFunctionCallTraitCandidate/2>;
 
   private predicate methodCallVisibleTraitCandidate = MethodTraitIsVisible::traitIsVisible/2;
 
@@ -1482,7 +1483,7 @@ private module MethodResolution {
   ) {
     exists(string name, int arity |
       mc.hasNameAndArity(name, arity) and
-      methodInfoNonBlanket(m, name, arity, selfPos, i, self, strippedTypePath, strippedType)
+      assocFunctionInfoNonBlanket(m, name, arity, selfPos, i, self, strippedTypePath, strippedType)
     |
       i =
         any(Impl impl |
@@ -1516,7 +1517,8 @@ private module MethodResolution {
   ) {
     exists(string name, int arity |
       mc.hasNameAndArity(name, arity) and
-      methodInfoBlanketLike(m, name, arity, selfPos, impl, _, self, blanketPath, blanketTypeParam)
+      assocFunctionSelfInfoBlanketLike(m, name, arity, selfPos, impl, _, self, blanketPath,
+        blanketTypeParam)
     |
       methodCallVisibleImplTraitCandidate(mc, impl)
       or
@@ -2170,7 +2172,7 @@ private module MethodResolution {
       exists(TypePath strippedTypePath, Type strippedType, string name, int arity |
         this.hasSignature(_, selfPos, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
-          methodInfoNonBlanket(_, name, arity, selfPos, i, _, strippedTypePath, strippedType) and
+          assocFunctionInfoNonBlanket(_, name, arity, selfPos, i, _, strippedTypePath, strippedType) and
           not i.hasTrait()
         |
           this.hasIncompatibleInherentTarget(i)
@@ -2340,7 +2342,7 @@ private module MethodResolution {
     }
 
     predicate relevantConstraint(AssocFunctionType constraint) {
-      methodInfo(_, _, _, _, _, constraint, _, _) // todo
+      assocFunctionInfo(_, _, _, _, _, constraint, _, _) // todo
     }
   }
 
@@ -2755,14 +2757,14 @@ private module NonMethodResolution {
     NonMethodFunction f, string name, int arity, ImplItemNode impl, Trait trait,
     FunctionPosition pos, AssocFunctionType t, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
-    functionInfoBlanketLike(f, name, arity, impl, trait, pos, t, blanketPath, blanketTypeParam) and
+    assocFunctionInfoBlanketLike(f, name, arity, impl, trait, pos, t, blanketPath, blanketTypeParam) and
     (
       if pos.isReturn()
       then
         // We only check that the context of the call provides relevant type information
         // when no argument can
         not exists(FunctionPosition pos0 |
-          functionInfoBlanketLike(f, name, arity, impl, trait, pos0, _, _, _) and
+          assocFunctionInfoBlanketLike(f, name, arity, impl, trait, pos0, _, _, _) and
           not pos0.isReturn()
         )
       else any()