wip

Author: hvitved

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

@@ -211,7 +211,7 @@ class AssocFunctionType extends MkAssocFunctionType {
 }
 
 pragma[nomagic]
-private Trait getALookupTrait(Type t) {
+Trait getALookupTrait(Type t) {
   result = t.(TypeParamTypeParameter).getTypeParam().(TypeParamItemNode).resolveABound()
   or
   result = t.(SelfTypeParameter).getTrait()

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

@@ -1392,6 +1392,10 @@ private module AssocFunctionResolution {
     )
   }
 
+  private module TypeOption = Option<Type>;
+
+  private class TypeOption = TypeOption::Option;
+
   /**
    * Holds if function `f` with the name `name` and the arity `arity` exists in
    * `i`, and the type at `selfPos` is `selfType`.
@@ -1402,12 +1406,16 @@ private module AssocFunctionResolution {
    * and `strippedType` is the type inside the reference.
    *
    * `selfPosAdj` is the function-call adjusted version of `selfPos`.
+   *
+   * `implType` is the type being implemented (`None` when `i` is a trait).
+   *
+   * `isMethod` indicates whether `f` is a method.
    */
   pragma[nomagic]
   private predicate assocFunctionInfo(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
-    TypeOption implType, boolean isMethod
+    TypeOption implType, TypeOption trait, boolean isMethod
   ) {
     assocFunctionInfo(f, name, arity, i, selfPos, selfType) and
     strippedType = selfType.getTypeAt(strippedTypePath) and
@@ -1425,10 +1433,19 @@ private module AssocFunctionResolution {
       traitImplSelfTypeParameterOccurrence(i, f, selfPos)
     ) and
     (
-      not i instanceof Impl and
+      implType.asSome() = resolveImplSelfTypeAt(i, TypePath::nil())
+      or
+      i instanceof Trait and
       implType.isNone()
+    ) and
+    (
+      trait.asSome() =
+        [
+          TTrait(i).(Type),
+          TTrait(i.(ImplItemNode).resolveTraitTy()).(Type)
+        ]
       or
-      implType.asSome() = resolveImplSelfTypeAt(i, TypePath::nil())
+      i.(Impl).isInherent() and trait.isNone()
     ) and
     if f instanceof Method then isMethod = true else isMethod = false
   }
@@ -1437,21 +1454,21 @@ private module AssocFunctionResolution {
   private predicate assocFunctionInfoNonBlanketLike0(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
-    TypeOption implType, boolean isMethod
+    TypeOption implType, TypeOption trait, boolean isMethod
   ) {
     assocFunctionInfo(f, name, arity, selfPos, selfPosAdj, i, selfType, strippedTypePath,
-      strippedType, implType, isMethod) and
+      strippedType, implType, trait, isMethod) and
     not BlanketImplementation::isBlanketLike(i, _, _)
   }
 
   pragma[nomagic]
   private predicate assocFunctionInfoNonBlanketLikeTypeParam(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, TypeParam tp,
-    TypeOption implType, boolean isMethod
+    TypeOption implType, TypeOption trait, boolean isMethod
   ) {
     assocFunctionInfo(f, name, arity, selfPos, selfPosAdj, i, selfType, strippedTypePath,
-      TTypeParamTypeParameter(tp), implType, isMethod) and
+      TTypeParamTypeParameter(tp), implType, trait, isMethod) and
     not BlanketImplementation::isBlanketLike(i, _, _)
   }
 
@@ -1464,12 +1481,12 @@ private module AssocFunctionResolution {
   private predicate assocFunctionInfoNonBlanketLike(
     Function f, string name, int arity, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType,
-    TypeOption implType, boolean isMethod
+    TypeOption implType, TypeOption trait, boolean isMethod
   ) {
     assocFunctionInfoNonBlanketLike0(f, name, arity, selfPos, selfPosAdj, i, selfType,
-      strippedTypePath, strippedType, implType, isMethod) or
+      strippedTypePath, strippedType, implType, trait, isMethod) or
     assocFunctionInfoNonBlanketLikeTypeParam(f, name, arity, selfPos, selfPosAdj, i, selfType,
-      strippedTypePath, _, implType, isMethod)
+      strippedTypePath, _, implType, trait, isMethod)
   }
 
   /**
@@ -1500,33 +1517,58 @@ private module AssocFunctionResolution {
   pragma[nomagic]
   private predicate assocFunctionTraitInfo(string name, int arity, Trait trait) {
     exists(ImplItemNode i |
-      assocFunctionInfo(_, name, arity, _, _, i, _, _, _, _, _) and
+      assocFunctionInfo(_, name, arity, _, _, i, _, _, _, _, _, _) and
       trait = i.resolveTraitTy()
     )
     or
-    assocFunctionInfo(_, name, arity, _, _, trait, _, _, _, _, _)
+    assocFunctionInfo(_, name, arity, _, _, trait, _, _, _, _, _, _)
   }
 
   pragma[nomagic]
   private predicate assocFunctionCallTraitCandidate(Element afc, Trait trait) {
     afc =
       any(AssocFunctionCall afc0 |
         exists(string name, int arity |
-          afc0.hasNameAndArity(name, arity, _, _) and
+          afc0.hasNameAndArity(name, arity) and
           assocFunctionTraitInfo(name, arity, trait) and
-          not afc0.hasTrait()
+          not afc0.hasATrait()
         )
       )
   }
 
   private module AssocFunctionTraitIsVisible = TraitIsVisible<assocFunctionCallTraitCandidate/2>;
 
-  predicate callVisibleTraitCandidate = AssocFunctionTraitIsVisible::traitIsVisible/2;
-
+  // private predicate callVisibleTraitCandidate = AssocFunctionTraitIsVisible::traitIsVisible/2;
   bindingset[afc, impl]
   pragma[inline_late]
   private predicate callVisibleImplTraitCandidate(AssocFunctionCall afc, ImplItemNode impl) {
-    callVisibleTraitCandidate(afc, impl.resolveTraitTy())
+    AssocFunctionTraitIsVisible::traitIsVisible(afc, impl.resolveTraitTy())
+  }
+
+  private Type getNonTypeParameterTypeQualifier(AssocFunctionCall afc) {
+    result = getCallExprTypeQualifier(afc, TypePath::nil(), _) and
+    not result instanceof TypeParameter
+  }
+
+  pragma[nomagic]
+  private predicate callInfo(
+    AssocFunctionCall afc, string name, int arity, TypeOption typeQualifier,
+    TypeOption traitQualifier, boolean hasReceiver
+  ) {
+    afc.hasNameAndArity(name, arity) and
+    (if afc.hasReceiver() then hasReceiver = true else hasReceiver = false) and
+    (
+      typeQualifier.asSome() = getNonTypeParameterTypeQualifier(afc)
+      or
+      not exists(getNonTypeParameterTypeQualifier(afc)) and
+      typeQualifier.isNone()
+    ) and
+    (
+      traitQualifier.asSome() = TTrait(afc.getATrait())
+      or
+      not afc.hasATrait() and
+      traitQualifier.isNone()
+    )
   }
 
   /**
@@ -1546,23 +1588,15 @@ private module AssocFunctionResolution {
     AssocFunctionCall afc, Function f, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplOrTraitItemNode i, AssocFunctionType selfType, TypePath strippedTypePath, Type strippedType
   ) {
-    exists(string name, int arity, TypeOption implType, boolean isMethod |
-      afc.hasNameAndArity(name, arity, [implType, any(TypeOption non | non.isNone())], isMethod) and
+    exists(string name, int arity, TypeOption implType, TypeOption trait, boolean isMethod |
+      callInfo(afc, name, arity, [implType, any(TypeOption non | non.isNone())],
+        [trait, any(TypeOption non | non.isNone())], [false, isMethod]) and
       assocFunctionInfoNonBlanketLike(f, name, arity, selfPos, selfPosAdj, i, selfType,
-        strippedTypePath, strippedType, implType, isMethod)
+        strippedTypePath, strippedType, implType, trait, isMethod)
     |
-      i.(Impl).isInherent() and
-      not afc.hasTrait()
-      or
-      callVisibleImplTraitCandidate(afc, i)
-      or
-      callVisibleTraitCandidate(afc, i)
-      or
-      exists(Trait trait | trait = afc.getTrait() |
-        i.(ImplItemNode).resolveTraitTy() = trait
-        or
-        i = trait
-      )
+      if not afc.hasATrait() and i.(Impl).hasTrait()
+      then callVisibleImplTraitCandidate(afc, i)
+      else any()
     )
   }
 
@@ -1583,21 +1617,16 @@ private module AssocFunctionResolution {
     AssocFunctionCall afc, Function f, FunctionPosition selfPos, FunctionPosition selfPosAdj,
     ImplItemNode impl, AssocFunctionType self, TypePath blanketPath, TypeParam blanketTypeParam
   ) {
-    exists(string name, int arity, boolean isMethod |
-      afc.hasNameAndArity(name, arity, _, isMethod) and
-      assocFunctionSelfInfoBlanketLike(f, name, arity, selfPos, selfPosAdj, impl, _, self,
+    exists(string name, int arity, Trait trait, boolean isMethod |
+      callInfo(afc, name, arity, _,
+        [TypeOption::some(TTrait(trait)), any(TypeOption non | non.isNone())], [false, isMethod]) and
+      assocFunctionSelfInfoBlanketLike(f, name, arity, selfPos, selfPosAdj, impl, trait, self,
         blanketPath, blanketTypeParam, isMethod)
     |
-      callVisibleImplTraitCandidate(afc, impl)
-      or
-      impl.resolveTraitTy() = afc.getTrait()
+      if not afc.hasATrait() then callVisibleImplTraitCandidate(afc, impl) else any()
     )
   }
 
-  private module TypeOption = Option<Type>;
-
-  private class TypeOption = TypeOption::Option;
-
   /**
    * A (potential) call to an associated function.
    *
@@ -1619,7 +1648,7 @@ private module AssocFunctionResolution {
    * [1]: https://doc.rust-lang.org/std/ops/trait.Index.html
    */
   abstract class AssocFunctionCall extends Expr {
-    abstract predicate hasNameAndArity(string name, int arity, TypeOption implType, boolean isMethod);
+    abstract predicate hasNameAndArity(string name, int arity);
 
     abstract Expr getNonReturnNodeAt(FunctionPosition apos);
 
@@ -1639,6 +1668,14 @@ private module AssocFunctionResolution {
     /** Holds if this call targets a trait. */
     predicate hasTrait() { exists(this.getTrait()) }
 
+    Trait getATrait() {
+      result = this.getTrait()
+      or
+      result = getALookupTrait(getCallExprTypeQualifier(this, TypePath::nil(), _))
+    }
+
+    predicate hasATrait() { exists(this.getATrait()) }
+
     Type getTypeAt(FunctionPosition pos, TypePath path) {
       result = inferType(this.getNodeAt(pos), path)
     }
@@ -2077,11 +2114,9 @@ private module AssocFunctionResolution {
 
   private class AssocFunctionCallMethodCallExpr extends AssocFunctionCall instanceof MethodCallExpr {
     pragma[nomagic]
-    override predicate hasNameAndArity(string name, int arity, TypeOption implType, boolean isMethod) {
+    override predicate hasNameAndArity(string name, int arity) {
       name = super.getIdentifier().getText() and
-      arity = super.getArgList().getNumberOfArgs() + 1 and
-      implType.isNone() and
-      isMethod = true
+      arity = super.getArgList().getNumberOfArgs() + 1
     }
 
     override Expr getNonReturnNodeAt(FunctionPosition pos) {
@@ -2100,11 +2135,9 @@ private module AssocFunctionResolution {
     }
 
     pragma[nomagic]
-    override predicate hasNameAndArity(string name, int arity, TypeOption implType, boolean isMethod) {
+    override predicate hasNameAndArity(string name, int arity) {
       (if this.isInMutableContext() then name = "index_mut" else name = "index") and
-      arity = 2 and
-      implType.isNone() and
-      isMethod = true
+      arity = 2
     }
 
     override Expr getNonReturnNodeAt(FunctionPosition pos) {
@@ -2133,22 +2166,9 @@ private module AssocFunctionResolution {
     }
 
     pragma[nomagic]
-    private Type getNonTypeParameterTypeQualifier() {
-      result = getCallExprTypeQualifier(this, TypePath::nil(), _) and
-      not result instanceof TypeParameter
-    }
-
-    pragma[nomagic]
-    override predicate hasNameAndArity(string name, int arity, TypeOption implType, boolean isMethod) {
+    override predicate hasNameAndArity(string name, int arity) {
       name = CallExprImpl::getFunctionPath(this).getText() and
-      arity = super.getArgList().getNumberOfArgs() and
-      (
-        not exists(this.getNonTypeParameterTypeQualifier()) and
-        implType.isNone()
-        or
-        implType.asSome() = this.getNonTypeParameterTypeQualifier()
-      ) and
-      isMethod = [false, true]
+      arity = super.getArgList().getNumberOfArgs()
     }
 
     override Expr getNonReturnNodeAt(FunctionPosition pos) {
@@ -2169,11 +2189,9 @@ private module AssocFunctionResolution {
 
   final class AssocFunctionCallOperation extends AssocFunctionCall instanceof Operation {
     pragma[nomagic]
-    override predicate hasNameAndArity(string name, int arity, TypeOption implType, boolean isMethod) {
+    override predicate hasNameAndArity(string name, int arity) {
       super.isOverloaded(_, name, _) and
-      arity = super.getNumberOfOperands() and
-      implType.isNone() and
-      isMethod = true
+      arity = super.getNumberOfOperands()
     }
 
     override Expr getNonReturnNodeAt(FunctionPosition pos) {
@@ -2289,7 +2307,7 @@ private module AssocFunctionResolution {
         selfPos.isTypeQualifier() and strippedTypePath.isEmpty()
       ) and
       afc = afc_ and
-      afc.hasNameAndArity(name, arity, _, _) and
+      afc.hasNameAndArity(name, arity) and
       pos = selfPosAdj
     }
 
@@ -2316,7 +2334,7 @@ private module AssocFunctionResolution {
         this.hasSignature(_, selfPosAdj, strippedTypePath, strippedType, name, arity) and
         forall(Impl i |
           assocFunctionInfoNonBlanketLike(_, name, arity, _, selfPosAdj, i, _, strippedTypePath,
-            strippedType, _, _) and
+            strippedType, _, _, _) and
           i.isInherent()
         |
           this.hasIncompatibleInherentTarget(i)
@@ -2327,7 +2345,7 @@ private module AssocFunctionResolution {
     pragma[nomagic]
     private predicate argIsInstantiationOf(ImplOrTraitItemNode i, string name, int arity) {
       ArgIsInstantiationOfSelfParam::argIsInstantiationOf(this, i, _) and
-      afc_.hasNameAndArity(name, arity, _, _)
+      afc_.hasNameAndArity(name, arity)
     }
 
     pragma[nomagic]
@@ -2487,7 +2505,7 @@ private module AssocFunctionResolution {
     }
 
     predicate relevantConstraint(AssocFunctionType constraint) {
-      assocFunctionInfo(_, _, _, _, _, _, constraint, _, _, _, _)
+      assocFunctionInfo(_, _, _, _, _, _, constraint, _, _, _, _, _)
     }
   }
 
@@ -4007,8 +4025,8 @@ private module Debug {
   Locatable getRelevantLocatable() {
     exists(string filepath, int startline, int startcolumn, int endline, int endcolumn |
       result.getLocation().hasLocationInfo(filepath, startline, startcolumn, endline, endcolumn) and
-      filepath.matches("%/main.rs") and
-      startline = 50
+      filepath.matches("%/overloading.rs") and
+      startline = 57
     )
   }