wip2

Author: hvitved

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

@@ -963,7 +963,9 @@ final class TraitItemNode extends ImplOrTraitItemNode, TypeItemNode instanceof T
   Path getABoundPath() { result = super.getATypeBound().getTypeRepr().(PathTypeRepr).getPath() }
 
   pragma[nomagic]
-  ItemNode resolveABound() { result = resolvePath(this.getABoundPath()) }
+  ItemNode resolveBound(Path path) { path = this.getABoundPath() and result = resolvePath(path) }
+
+  ItemNode resolveABound() { result = this.resolveBound(_) }
 
   override AssocItemNode getAnAssocItem() { result = this.getADescendant() }
 

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

@@ -991,8 +991,10 @@ private module MethodResolution {
     )
   }
 
+  private module MethodTraitIsVisible = TraitIsVisible<methodCallTraitCandidate/2>;
+
   private predicate methodCallVisibleTraitCandidate(MethodCall mc, Trait trait) {
-    TraitIsVisible<methodCallTraitCandidate/2>::traitIsVisible(mc, trait)
+    MethodTraitIsVisible::traitIsVisible(mc, trait)
   }
 
   bindingset[mc, impl]
@@ -1820,33 +1822,33 @@ private Type inferMethodCallType(AstNode n, TypePath path) {
  * "calls" to tuple variants and tuple structs.
  */
 private module NonMethodResolution {
-  private import FunctionOverloading
-
   /**
-   * Holds if the associated function `implFunction` implements `traitFunction`,
-   * which belongs to `trait`, and resolving the function `implFunction` requires
-   * inspecting the type of applied _arguments_ at position `pos` in order to
-   * determine whether it is the correct resolution.
+   * Holds if the associated function `implFunction` at `impl` implements
+   * `traitFunction`, which belongs to `trait`, and resolving the function
+   * `implFunction` requires inspecting the type of applied _arguments_ at
+   * position `pos` in order to determine whether it is the correct resolution.
    *
    * `type` is the type at `pos` of `implFunction` which mathces a type parameter of
    * `traitFunction` at `pos`.
    */
   pragma[nomagic]
   private predicate traitFunctionDependsOnArgument(
     TraitItemNode trait, NonMethodFunction traitFunction, FunctionTypePosition pos, Type type,
-    NonMethodFunction implFunction
+    ImplItemNode impl, NonMethodFunction implFunction
   ) {
     exists(TypePath path |
-      functionTypeAtPath(implFunction, pos, path, type) and
+      functionTypeAtPath(implFunction, impl, pos, path, type) and
       implFunction.implements(traitFunction) and
-      traitTypeParameterOccurrence(trait, traitFunction, _, pos, path, _)
+      FunctionOverloading::traitTypeParameterOccurrence(trait, traitFunction, _, pos, path, _)
     |
       not pos.isReturn()
       or
       // We only check that the context of the call provides relevant type information
       // when no argument can
       not exists(FunctionTypePosition pos0 |
-        traitTypeParameterOccurrence(trait, traitFunction, _, pos0, _, _) and
+        FunctionOverloading::traitTypeParameterOccurrence(trait, traitFunction, _, pos0, _, _) or
+        FunctionOverloading::functionResolutionDependsOnArgument(impl, implFunction, pos0, _, _)
+      |
         not pos0.isReturn()
       )
     )
@@ -1882,6 +1884,8 @@ private module NonMethodResolution {
     )
   }
 
+  private module BlanketTraitIsVisible = TraitIsVisible<blanketCallTraitCandidate/2>;
+
   private Type getTypeAt(NonMethodCall fc, FunctionTypePosition pos, TypePath path) {
     result = inferType(fc.getNodeAt(pos), path)
   }
@@ -1896,7 +1900,7 @@ private module NonMethodResolution {
       exists(getTypeAt(fc, pos, blanketPath)) and
       functionInfoBlanketRelevantPos(f, name, arity, impl, trait, pos, t, blanketPath,
         blanketTypeParam) and
-      TraitIsVisible<blanketCallTraitCandidate/2>::traitIsVisible(fc, trait)
+      BlanketTraitIsVisible::traitIsVisible(fc, trait)
     )
   }
 
@@ -2022,7 +2026,7 @@ private module NonMethodResolution {
     pragma[nomagic]
     private NonMethodFunction resolveCallTargetRec() {
       result = this.resolveCallTargetBlanketCand(_) and
-      not functionResolutionDependsOnArgument(_, result, _, _, _)
+      not FunctionOverloading::functionResolutionDependsOnArgument(_, result, _, _, _)
       or
       NonMethodArgsAreInstantiationsOf::argsAreInstantiationsOf(this, _, result)
     }
@@ -2031,7 +2035,7 @@ private module NonMethodResolution {
     ItemNode resolveCallTargetNonRec() {
       not this.(Call).hasTrait() and
       result = this.getPathResolutionResolved() and
-      not functionResolutionDependsOnArgument(_, result, _, _, _)
+      not FunctionOverloading::functionResolutionDependsOnArgument(_, result, _, _, _)
     }
 
     pragma[inline]
@@ -2054,12 +2058,13 @@ private module NonMethodResolution {
         |
           FunctionOverloading::functionResolutionDependsOnArgument(i, f, pos, _, t0)
           or
-          traitFunctionDependsOnArgument(_, _, pos, t0, f)
+          traitFunctionDependsOnArgument(_, _, pos, t0, i, f)
         )
         or
         // match against the trait function itself
         exists(Trait trait |
-          traitTypeParameterOccurrence(trait, f, _, pos, _, TSelfTypeParameter(trait))
+          FunctionOverloading::traitTypeParameterOccurrence(trait, f, _, pos, _,
+            TSelfTypeParameter(trait))
         )
       )
     }
@@ -2072,14 +2077,15 @@ private module NonMethodResolution {
       predicate hasTargetCand(ImplOrTraitItemNode i, Function f) {
         f = this.resolveAssocCallTargetCand(i)
         or
-        exists(TraitItemNode trait, NonMethodFunction resolved, Function f1 |
+        exists(TraitItemNode trait, NonMethodFunction resolved, ImplItemNode i1, Function f1 |
           this.hasTraitResolved(trait, resolved) and
-          traitFunctionDependsOnArgument(trait, resolved, _, _, f1) and
-          f = i.getASuccessor(_)
+          traitFunctionDependsOnArgument(trait, resolved, _, _, i1, f1)
         |
-          f = f1
+          f = f1 and
+          i = i1
           or
-          f = resolved
+          f = resolved and
+          i = trait
         )
       }
     }

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

@@ -78,8 +78,8 @@ predicate traitTypeParameterOccurrence(
   TraitItemNode trait, Function f, string functionName, FunctionTypePosition pos, TypePath path,
   TypeParameter tp
 ) {
-  f = trait.getAssocItem(functionName) and
-  functionTypeAtPath(f, pos, path, tp) and
+  f = trait.getASuccessor(functionName) and
+  functionTypeAtPath(f, trait, pos, path, tp) and
   tp = trait.(TraitTypeAbstraction).getATypeParameter()
 }
 
@@ -120,7 +120,7 @@ predicate functionResolutionDependsOnArgument(
   exists(TraitItemNode trait, string functionName |
     implHasSibling(impl, trait) and
     traitTypeParameterOccurrence(trait, _, functionName, pos, path, _) and
-    functionTypeAtPath(f, pos, path, type) and
+    functionTypeAtPath(f, impl, pos, path, type) and
     f = impl.getASuccessor(functionName) and
     not pos.isReturn()
   )

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

@@ -57,11 +57,6 @@ class FunctionTypePosition extends TFunctionTypePosition {
   }
 }
 
-pragma[nomagic]
-predicate functionTypeAtPath(Function f, FunctionTypePosition pos, TypePath path, Type type) {
-  type = pos.getTypeMention(f).resolveTypeAt(path)
-}
-
 /**
  * A helper module for implementing `Matching(WithEnvironment)InputSig` with
  * `DeclarationPosition = AccessPosition = FunctionTypePosition`.
@@ -82,15 +77,17 @@ private newtype TFunctionType =
     exists(pos.getTypeMention(f))
   } or
   MkInheritedFunctionType(
-    Function f, FunctionTypePosition pos, ImplOrTraitItemNode parent, ImplOrTraitItemNode i
+    Function f, FunctionTypePosition pos, TypeMention parentMention, ImplOrTraitItemNode parent,
+    ImplOrTraitItemNode i
   ) {
     exists(FunctionType inherited |
       inherited.appliesTo(f, pos, parent) and
       f = i.getASuccessor(_)
     |
-      parent = i.(ImplItemNode).resolveTraitTy()
+      parent = i.(ImplItemNode).resolveTraitTy() and
+      parentMention = i.(ImplItemNode).getTraitPath()
       or
-      parent = i.(TraitItemNode).resolveABound()
+      parent = i.(TraitItemNode).resolveBound(parentMention)
     )
   }
 
@@ -135,9 +132,10 @@ class FunctionType extends TFunctionType {
   }
 
   private predicate isInheritedFunctionType(
-    Function f, FunctionTypePosition pos, ImplOrTraitItemNode parent, ImplOrTraitItemNode i
+    Function f, FunctionTypePosition pos, TypeMention parentMention, ImplOrTraitItemNode parent,
+    ImplOrTraitItemNode i
   ) {
-    this = MkInheritedFunctionType(f, pos, parent, i)
+    this = MkInheritedFunctionType(f, pos, parentMention, parent, i)
   }
 
   /**
@@ -147,37 +145,49 @@ class FunctionType extends TFunctionType {
   predicate appliesTo(Function f, FunctionTypePosition pos, ImplOrTraitItemNode i) {
     this.isFunctionType(f, pos, i)
     or
-    this.isInheritedFunctionType(f, pos, _, i)
+    this.isInheritedFunctionType(f, pos, _, _, i)
   }
 
+  /**
+   * Gets the type of this function at the given position and path.
+   */
   pragma[nomagic]
-  private Type getTypeAt0(TypePath path) {
+  Type getDeclaredTypeAt(TypePath path) {
     exists(Function f, FunctionTypePosition pos |
       this.isFunctionType(f, pos, _) and
-      functionTypeAtPath(f, pos, path, result)
+      result = pos.getTypeMention(f).resolveTypeAt(path)
     )
     or
     exists(
-      Function f, FunctionTypePosition pos, FunctionType parentType, ImplOrTraitItemNode parent,
-      ImplOrTraitItemNode i
+      Function f, FunctionTypePosition pos, TypeMention parentMention, ImplOrTraitItemNode parent,
+      FunctionType parentType, ImplOrTraitItemNode i
     |
-      this.isInheritedFunctionType(f, pos, parent, i) and
+      this.isInheritedFunctionType(f, pos, parentMention, parent, i) and
       parentType.appliesTo(f, pos, parent)
     |
-      result = parentType.getTypeAt0(path) and
-      not result instanceof TSelfTypeParameter
+      result = parentType.getDeclaredTypeAt(path) and
+      not result instanceof TypeParameter
       or
-      exists(TypePath prefix, TypePath suffix |
+      exists(TypePath prefix, TypePath suffix | path = prefix.append(suffix) |
         parentType.hasSelfTypeParameterAt(prefix) and
-        result = resolveImplOrTraitType(i, suffix) and
-        path = prefix.append(suffix)
+        result = resolveImplOrTraitType(i, suffix)
+        or
+        exists(TypeParameter tp |
+          parentType.hasTypeParameterAt(prefix, tp) and
+          result = parentMention.resolveTypeAt(TypePath::singleton(tp).appendInverse(suffix))
+        )
       )
     )
   }
 
+  pragma[nomagic]
+  private predicate hasTypeParameterAt(TypePath path, TypeParameter tp) {
+    this.getDeclaredTypeAt(path) = tp
+  }
+
   pragma[nomagic]
   private predicate hasSelfTypeParameterAt(TypePath path) {
-    this.getTypeAt0(path) = TSelfTypeParameter(_)
+    this.hasTypeParameterAt(path, TSelfTypeParameter(_))
   }
 
   /**
@@ -190,7 +200,7 @@ class FunctionType extends TFunctionType {
    * traits when matching.
    */
   Type getTypeAt(TypePath path) {
-    exists(Type t | t = this.getTypeAt0(path) |
+    exists(Type t | t = this.getDeclaredTypeAt(path) |
       not t instanceof SelfTypeParameter and
       result = t
       or
@@ -220,6 +230,20 @@ class FunctionType extends TFunctionType {
   Location getLocation() { result = this.getReportingNode().getLocation() }
 }
 
+/**
+ * Holds if the type of the function `f` at position `pos` and path `path` inside
+ * `i` is `type`.
+ */
+pragma[nomagic]
+predicate functionTypeAtPath(
+  Function f, ImplOrTraitItemNode i, FunctionTypePosition pos, TypePath path, Type type
+) {
+  exists(FunctionType ft |
+    ft.appliesTo(f, pos, i) and
+    type = ft.getDeclaredTypeAt(path)
+  )
+}
+
 private Trait getALookupTrait(Type t) {
   result = t.(TypeParamTypeParameter).getTypeParam().(TypeParamItemNode).resolveABound()
   or