wip

Author: hvitved

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

@@ -1238,6 +1238,22 @@ private Type substituteLookupTraits(Type t) {
   result = TTrait(getALookupTrait(t))
 }
 
+/**
+ * Gets the type qualifier of function call `ce`, if any.
+ *
+ * For example, the type qualifier of `Foo::<i32>::default()` is `Foo::<i32>`,
+ * but only when `Foo` is not a trait.
+ */
+pragma[nomagic]
+private Type getCallExprQualifierType(CallExpr ce, TypePath path) {
+  exists(PathExpr pe, TypeMention tm |
+    pe = ce.getFunction() and
+    tm = pe.getPath().getQualifier() and
+    result = tm.resolveTypeAt(path) and
+    not resolvePath(tm) instanceof Trait
+  )
+}
+
 /**
  * Provides logic for resolving method calls.
  *
@@ -1403,6 +1419,10 @@ private module MethodCallResolution {
     exists(string name, int arity |
       mc.(MethodCall).hasNameAndArity(name, arity) and
       methodTraitInfo(name, arity, trait)
+    |
+      not mc.(Call).hasTrait()
+      or
+      trait = mc.(Call).getTrait()
     )
   }
 
@@ -1492,9 +1512,15 @@ private module MethodCallResolution {
 
     abstract Expr getArgument(ArgumentPosition pos);
 
-    Expr getReceiver() { result = this.getArgument(any(ArgumentPosition pos | pos.isSelf())) }
+    abstract predicate supportsAutoDerefAndBorrow();
+
+    Type getArgumentTypeAt(ArgumentPosition pos, TypePath path) {
+      result = inferType(this.getArgument(pos), path)
+    }
 
-    private Type getReceiverTypeAt(TypePath path) { result = inferType(this.getReceiver(), path) }
+    private Type getReceiverTypeAt(TypePath path) {
+      result = this.getArgumentTypeAt(any(ArgumentPosition pos | pos.isSelf()), path)
+    }
 
     /**
      * Same as `getACandidateReceiverTypeAt`, but without borrows.
@@ -1541,7 +1567,7 @@ private module MethodCallResolution {
     }
 
     pragma[nomagic]
-    private Type getComplexstrippedType(TypePath strippedTypePath, string derefChainBorrow) {
+    private Type getComplexStrippedType(TypePath strippedTypePath, string derefChainBorrow) {
       result =
         this.getACandidateReceiverTypeAtSubstituteLookupTraits(strippedTypePath, derefChainBorrow) and
       isComplexRootStripped(strippedTypePath, result)
@@ -1553,10 +1579,11 @@ private module MethodCallResolution {
      */
     pragma[nomagic]
     private predicate hasNoCompatibleTargetNoBorrow(string derefChain) {
+      this.supportsAutoDerefAndBorrow() and
       exists(TypePath strippedTypePath, Type strippedType, string derefChainBorrow |
         derefChainBorrow = derefChain + ";" and
         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)
+        strippedType = this.getComplexStrippedType(strippedTypePath, derefChainBorrow)
       |
         // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
@@ -1576,7 +1603,7 @@ private module MethodCallResolution {
       exists(TypePath strippedTypePath, Type strippedType, string derefChainBorrow |
         derefChainBorrow = derefChain + ";borrow" and
         this.hasNoCompatibleTargetNoBorrow(derefChain) and
-        strippedType = this.getComplexstrippedType(strippedTypePath, derefChainBorrow)
+        strippedType = this.getComplexStrippedType(strippedTypePath, derefChainBorrow)
       |
         // todo: also check that all blanket implementation candidates are incompatible
         forall(ImplOrTraitItemNode i |
@@ -1656,6 +1683,8 @@ private module MethodCallResolution {
       or
       result = super.getArgList().getArg(pos.asPosition())
     }
+
+    override predicate supportsAutoDerefAndBorrow() { any() }
   }
 
   private class MethodCallIndexExpr extends MethodCall, IndexExpr {
@@ -1672,6 +1701,36 @@ private module MethodCallResolution {
       pos.asPosition() = 0 and
       result = this.getIndex()
     }
+
+    override predicate supportsAutoDerefAndBorrow() { any() }
+  }
+
+  private class MethodCallCallExpr extends MethodCall, CallExpr {
+    MethodCallCallExpr() {
+      not exists(Function f |
+        f = CallExprImpl::getResolvedFunction(this) and
+        not f.hasSelfParam()
+      )
+    }
+
+    pragma[nomagic]
+    override predicate hasNameAndArity(string name, int arity) {
+      name = CallExprImpl::getFunctionPath(this).getText() and
+      arity = this.getArgList().getNumberOfArgs() - 1
+    }
+
+    override Expr getArgument(ArgumentPosition pos) {
+      pos.isSelf() and
+      result = this.getArg(0)
+      or
+      result = this.getArgList().getArg(pos.asPosition() + 1)
+    }
+
+    Type getTypeAt(TypePath path) {
+      result = substituteLookupTraits(getCallExprQualifierType(this, path))
+    }
+
+    override predicate supportsAutoDerefAndBorrow() { none() }
   }
 
   private newtype TMethodCallCand =
@@ -1733,7 +1792,11 @@ private module MethodCallResolution {
     private Function resolveCallTargetCand(ImplOrTraitItemNode i) {
       exists(string name |
         IsInstantiationOf<MethodCallCand, FunctionType, MethodCallReceiverIsInstantiationOfInput>::isInstantiationOf(this,
-          i, _) and
+          i, _)
+        or
+        IsInstantiationOf<MethodCallCallExpr, TypeMentionTypeTree, MethodCallCallExprIsInstantiationOfInput>::isInstantiationOf(mc_,
+          i, _)
+      |
         mc_.hasNameAndArity(name, _) and
         result = getMethodSuccessor(i, name, _) and
         if i.(Impl).hasTrait()
@@ -1827,6 +1890,26 @@ private module MethodCallResolution {
     }
   }
 
+  /**
+   * A configuration for matching the type qualifier of a function call against
+   * the type being implemented in an `impl` block.
+   */
+  private module MethodCallCallExprIsInstantiationOfInput implements
+    IsInstantiationOfInputSig<MethodCallCallExpr, TypeMentionTypeTree>
+  {
+    pragma[nomagic]
+    predicate potentialInstantiationOf(
+      MethodCallCallExpr ce, TypeAbstraction abs, TypeMentionTypeTree constraint
+    ) {
+      exists(getCallExprQualifierType(ce, _)) and
+      abs =
+        any(ImplItemNode impl |
+          CallExprImpl::getResolvedFunction(ce) = impl.getASuccessor(_) and
+          constraint = impl.getSelfPath()
+        )
+    }
+  }
+
   /**
    * A configuration for anti-matching the type of a receiver against the type of
    * a `self` parameter in an inherent method.
@@ -2078,38 +2161,13 @@ private module FunctionCallResolution {
      * if any.
      */
     ItemNode getPathResolutionResolvedFunction() {
-      result = CallExprImpl::getResolvedFunction(this)
-    }
-
-    pragma[nomagic]
-    Type getTypeAt(TypePath path) {
-      result = substituteLookupTraits(inferType(this.getArg(0), path))
-    }
-
-    pragma[nomagic]
-    predicate hasSignature(
-      TypePath strippedTypePath, Type strippedType, TraitItemNode trait, Function resolved
-    ) {
-      this.getTypeAt(strippedTypePath) = strippedType and
-      resolved = this.getPathResolutionResolvedFunction() and
-      trait = this.(Call).getTrait() and
-      MethodCallResolution::isComplexRootStripped(strippedTypePath, strippedType)
-    }
-
-    pragma[nomagic]
-    private Function getATargetMethodCand() {
-      exists(ImplOrTraitItemNode i, FunctionType self |
-        FunctionMethodCallIsInstantiationOfInput::potentialInstantiationOf(this, i, self, result) and
-        IsInstantiationOf<FunctionCall, FunctionType, FunctionMethodCallIsInstantiationOfInput>::isInstantiationOf(this,
-          i, self)
-      )
+      result = CallExprImpl::getResolvedFunction(this) and
+      not result.(Function).hasSelfParam()
     }
 
     pragma[nomagic]
     private Function getAnAmbigousCandidate(FunctionTypePosition pos, TypePath path, Type type) {
       (
-        result = this.getATargetMethodCand()
-        or
         not this.(Call).hasTrait() and
         result = this.getPathResolutionResolvedFunction()
       ) and
@@ -2149,8 +2207,6 @@ private module FunctionCallResolution {
     pragma[nomagic]
     private ItemNode resolveUnambigousFunctionCallTarget() {
       (
-        result = this.getATargetMethodCand()
-        or
         not this.(Call).hasTrait() and
         result = this.getPathResolutionResolvedFunction()
       ) and
@@ -2163,113 +2219,6 @@ private module FunctionCallResolution {
       result = this.resolveAmbigousFunctionCallTarget()
     }
   }
-
-  private module SatisfiesBlanketConstraintInput implements
-    BlanketImplementation::SatisfiesBlanketConstraintInputSig<FunctionCall>
-  {
-    pragma[nomagic]
-    private predicate hasSignature(FunctionCall call, string name, int arity) {
-      name = CallExprImpl::getFunctionPath(call).getText() and
-      arity = call.getNumberOfArgs() - 1
-    }
-
-    pragma[nomagic]
-    private predicate hasBlanketCandidate(
-      FunctionCall call, Trait trait, Function m, TypePath blanketPath, TypeParam blanketTypeParam
-    ) {
-      not exists(call.getPathResolutionResolvedFunction()) and
-      exists(string name, int arity, ImplItemNode impl |
-        hasSignature(call, name, arity) and
-        MethodCallResolution::methodInfoBlanket(m, name, arity, impl, trait, _, blanketPath,
-          blanketTypeParam)
-      )
-    }
-
-    pragma[nomagic]
-    private predicate functionCallTraitCandidate(Element mc, Trait trait) {
-      hasBlanketCandidate(mc, trait, _, _, _)
-    }
-
-    pragma[nomagic]
-    predicate hasBlanketCandidate(
-      FunctionCall call, Function m, TypePath blanketPath, TypeParam blanketTypeParam
-    ) {
-      exists(Trait trait |
-        hasBlanketCandidate(call, trait, m, blanketPath, blanketTypeParam) and
-        TraitIsVisible<functionCallTraitCandidate/2>::traitIsVisible(call, trait)
-      )
-    }
-  }
-
-  /**
-   * A configuration for matching the type of the first argument in a function call
-   * against the type of a `self` parameter.
-   */
-  private module FunctionMethodCallIsInstantiationOfInput implements
-    IsInstantiationOfInputSig<FunctionCall, FunctionType>
-  {
-    pragma[nomagic]
-    private predicate methodInfo(
-      TypePath strippedTypePath, Type strippedType, TraitItemNode trait, Function f,
-      Function traitFunction
-    ) {
-      exists(ImplOrTraitItemNode i |
-        MethodCallResolution::methodInfo(f, _, _, i, _, strippedTypePath, strippedType) and
-        not i.(ImplItemNode).isBlanketImplementation() and
-        traitFunction = trait.getAnAssocItem() and
-        (
-          f.implements(traitFunction)
-          or
-          f = traitFunction
-        )
-      )
-    }
-
-    pragma[nomagic]
-    private predicate methodInfoTypeParam(
-      TypePath strippedTypePath, TraitItemNode trait, Function f, Function traitFunction
-    ) {
-      MethodCallResolution::methodInfoTypeParam(f, _, _, _, _, strippedTypePath, _) and
-      traitFunction = trait.getAnAssocItem() and
-      (
-        f.implements(traitFunction)
-        or
-        f = traitFunction
-      )
-    }
-
-    pragma[nomagic]
-    additional predicate potentialInstantiationOf(
-      FunctionCall call, ImplOrTraitItemNode i, FunctionType selfType, Function f
-    ) {
-      (
-        exists(
-          TraitItemNode trait, Function resolved, TypePath strippedTypePath, Type strippedType
-        |
-          call.hasSignature(strippedTypePath, strippedType, trait, resolved)
-        |
-          methodInfo(strippedTypePath, strippedType, trait, f, resolved)
-          or
-          methodInfoTypeParam(strippedTypePath, trait, f, resolved)
-        )
-        or
-        BlanketImplementation::SatisfiesBlanketConstraint<FunctionCall, SatisfiesBlanketConstraintInput>::satisfiesBlanketConstraint(call,
-          f)
-      ) and
-      MethodCallResolution::methodInfo(f, _, _, i, selfType, _, _)
-    }
-
-    pragma[nomagic]
-    predicate potentialInstantiationOf(
-      FunctionCall call, TypeAbstraction abs, FunctionType constraint
-    ) {
-      potentialInstantiationOf(call, abs, constraint, _)
-    }
-
-    predicate relevantTypeMention(FunctionType constraint) {
-      MethodCallResolution::methodInfo(_, _, _, _, constraint, _, _)
-    }
-  }
 }
 
 /**
@@ -2412,26 +2361,10 @@ private module FunctionCallMatchingInput implements MatchingInputSig {
       result = this and apos.isReturn()
     }
 
-    /**
-     * Gets the type qualifier of this function call, if any.
-     *
-     * For example, the type qualifier of `Foo::<i32>::default()` is `Foo::<i32>`,
-     * but only when `Foo` is not a trait.
-     */
-    pragma[nomagic]
-    private Type getQualifierType(TypePath path) {
-      exists(PathExpr pe, TypeMention tm |
-        pe = this.getFunction() and
-        tm = pe.getPath().getQualifier() and
-        result = tm.resolveTypeAt(path) and
-        not resolvePath(tm) instanceof Trait
-      )
-    }
-
     pragma[nomagic]
     Type getInferredType(AccessPosition apos, TypePath path) {
       apos.asArgumentPosition().isSelf() and
-      result = this.getQualifierType(path)
+      result = getCallExprQualifierType(this, path)
       or
       result = inferType(this.getNodeAt(apos), path)
     }

rust/ql/test/library-tests/type-inference/CONSISTENCY/PathResolutionConsistency.expected

@@ -5,12 +5,6 @@ multipleCallTargets
 | dereference.rs:184:17:184:30 | ... .foo() |
 | dereference.rs:186:17:186:25 | S.bar(...) |
 | dereference.rs:187:17:187:29 | S.bar(...) |
-| main.rs:540:26:540:42 | x.common_method() |
-| main.rs:541:26:541:45 | ...::common_method(...) |
-| main.rs:547:26:547:56 | ...::common_method(...) |
-| main.rs:551:26:551:49 | ...::common_method(...) |
-| main.rs:552:26:552:56 | ...::common_method(...) |
-| main.rs:556:26:556:37 | ...::m(...) |
 | main.rs:1809:13:1809:63 | ... .partial_cmp(...) |
 | main.rs:2324:9:2324:34 | ...::my_from2(...) |
 | main.rs:2325:9:2325:33 | ...::my_from2(...) |