perf

Author: hvitved

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

@@ -1243,7 +1243,7 @@ private module MethodCallResolution {
   }
 
   pragma[nomagic]
-  private predicate methodInfoTypeParam(
+  predicate methodInfoTypeParam(
     Function m, string name, int arity, ImplOrTraitItemNode i, FunctionType selfType,
     TypePath strippedRootTypePath
   ) {
@@ -1853,21 +1853,22 @@ private Type inferMethodCallExprType(AstNode n, TypePath path) {
 private module FunctionCallResolution {
   private import FunctionOverloading
 
-  bindingset[trait, resolved, result]
-  pragma[inline_late]
-  Function assocTraitFunctionDependsOnArgument(
-    TraitItemNode trait, Function resolved, FunctionTypePosition pos, TypePath path, Type type
+  pragma[nomagic]
+  private predicate assocTraitFunctionDependsOnArgument(
+    TraitItemNode trait, Function traitFunction, FunctionTypePosition pos, Function implFunction,
+    TypePath path, Type type
   ) {
-    not resolved.hasSelfParam() and
-    functionTypeAtPath(result, pos, path, type) and
-    traitTypeParameterOccurrence(trait, resolved, _, pos, _, _) and
+    not traitFunction.hasSelfParam() and
+    functionTypeAtPath(implFunction, pos, path, type) and
+    implFunction.implements(traitFunction) and
+    traitTypeParameterOccurrence(trait, traitFunction, _, pos, _, _) and
     (
       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, resolved, _, pos0, _, _) and
+        traitTypeParameterOccurrence(trait, traitFunction, _, pos0, _, _) and
         not pos0.isReturn()
       )
     )
@@ -1879,51 +1880,35 @@ private module FunctionCallResolution {
       result = CallExprImpl::getResolvedFunction(this)
     }
 
-    ItemNode getPathResolutionResolvedFunctionOrImplementation(ItemNode resolved) {
-      resolved = this.getPathResolutionResolvedFunction() and
-      (
-        result = resolved
-        or
-        result.(AssocItem).implements(resolved)
-      )
-    }
-
     pragma[nomagic]
     Type getTypeAt(TypePath path) {
       result = substituteLookupTraits(inferType(this.getArg(0), path))
     }
 
     pragma[nomagic]
     predicate hasInfo(
-      TypePath strippedRootTypePath, Type strippedRootType, TraitItemNode trait, Function resolved,
-      Function f
+      TypePath strippedRootTypePath, Type strippedRootType, TraitItemNode trait, Function resolved
     ) {
-      trait = this.(Call).getTrait() and
       this.getTypeAt(strippedRootTypePath) = strippedRootType and
-      MethodCallResolution::isComplexStrippedSelfRoot(strippedRootTypePath, strippedRootType) and
-      f = this.getPathResolutionResolvedFunctionOrImplementation(resolved)
+      resolved = this.getPathResolutionResolvedFunction() and
+      trait = this.(Call).getTrait() and
+      MethodCallResolution::isComplexStrippedSelfRoot(strippedRootTypePath, strippedRootType)
     }
 
     pragma[nomagic]
-    private Function getACandidateTraitMethod() {
-      exists(TraitItemNode trait, ImplOrTraitItemNode i, FunctionType self, Function resolved |
+    private Function getATargetMethodCand() {
+      exists(TraitItemNode trait, ImplOrTraitItemNode i, FunctionType self |
         FunctionMethodCallIsInstantiationOfInput::potentialInstantiationOf(this, trait, i, self,
-          resolved, result) and
+          result) and
         IsInstantiationOf<FunctionCall, FunctionType, FunctionMethodCallIsInstantiationOfInput>::isInstantiationOf(this,
           i, self)
       )
     }
 
     pragma[nomagic]
     private Function getAnAmbigousCandidate(FunctionTypePosition pos, TypePath path, Type type) {
-      exists(TraitItemNode trait, Function resolved |
-        result = this.getPathResolutionResolvedFunctionOrImplementation(resolved) and
-        trait = this.(Call).getTrait() and
-        result = assocTraitFunctionDependsOnArgument(trait, resolved, pos, path, type)
-      )
-      or
       (
-        result = this.getACandidateTraitMethod()
+        result = this.getATargetMethodCand()
         or
         not this.(Call).hasTrait() and
         result = this.getPathResolutionResolvedFunction()
@@ -1939,18 +1924,32 @@ private module FunctionCallResolution {
       result = substituteLookupTraits(inferType(this, path))
     }
 
+    pragma[nomagic]
+    private predicate hasInfo2(
+      TraitItemNode trait, Function resolved, FunctionTypePosition pos, TypePath path, Type type
+    ) {
+      resolved = this.getPathResolutionResolvedFunction() and
+      trait = this.(Call).getTrait() and
+      type = this.inferArgumentType(pos, path)
+    }
+
     pragma[nomagic]
     private Function resolveAmbigousFunctionCallTarget() {
       exists(FunctionTypePosition pos, TypePath path, Type type |
         result = this.getAnAmbigousCandidate(pos, path, type) and
         type = this.inferArgumentType(pos, path)
+        or
+        exists(TraitItemNode trait, Function resolved |
+          this.hasInfo2(trait, resolved, pos, path, type) and
+          assocTraitFunctionDependsOnArgument(trait, resolved, pos, result, path, type)
+        )
       )
     }
 
     pragma[nomagic]
     private ItemNode resolveUnambigousFunctionCallTarget() {
       (
-        result = this.getACandidateTraitMethod()
+        result = this.getATargetMethodCand()
         or
         not this.(Call).hasTrait() and
         result = this.getPathResolutionResolvedFunction()
@@ -1973,22 +1972,52 @@ private module FunctionCallResolution {
     IsInstantiationOfInputSig<FunctionCall, FunctionType>
   {
     pragma[nomagic]
-    additional predicate potentialInstantiationOf(
-      FunctionCall call, TraitItemNode trait, ImplOrTraitItemNode i, FunctionType self,
-      Function resolved, Function f
+    private predicate methodInfo(
+      TypePath strippedRootTypePath, Type strippedRootType, TraitItemNode trait, Function f,
+      Function traitFunction
     ) {
-      exists(TypePath strippedRootTypePath, Type strippedRootType |
-        call.hasInfo(strippedRootTypePath, strippedRootType, trait, resolved, f) and
-        MethodCallResolution::methodInfoMatch(f, _, _, i, self, strippedRootTypePath,
-          strippedRootType)
+      MethodCallResolution::methodInfo(f, _, _, _, _, strippedRootTypePath, strippedRootType) and
+      traitFunction = trait.getAnAssocItem() and
+      (
+        f.implements(traitFunction)
+        or
+        f = traitFunction
       )
     }
 
+    pragma[nomagic]
+    private predicate methodInfoTypeParam(
+      TypePath strippedRootTypePath, TraitItemNode trait, Function f, Function traitFunction
+    ) {
+      MethodCallResolution::methodInfoTypeParam(f, _, _, _, _, strippedRootTypePath) and
+      traitFunction = trait.getAnAssocItem() and
+      (
+        f.implements(traitFunction)
+        or
+        f = traitFunction
+      )
+    }
+
+    pragma[nomagic]
+    additional predicate potentialInstantiationOf(
+      FunctionCall call, TraitItemNode trait, ImplOrTraitItemNode i, FunctionType selfType,
+      Function f
+    ) {
+      exists(Function resolved, TypePath strippedRootTypePath, Type strippedRootType |
+        call.hasInfo(strippedRootTypePath, strippedRootType, trait, resolved)
+      |
+        methodInfo(strippedRootTypePath, strippedRootType, trait, f, resolved)
+        or
+        methodInfoTypeParam(strippedRootTypePath, trait, f, resolved)
+      ) and
+      MethodCallResolution::methodInfo(f, _, _, i, selfType, _, _)
+    }
+
     pragma[nomagic]
     predicate potentialInstantiationOf(
       FunctionCall call, TypeAbstraction abs, FunctionType constraint
     ) {
-      potentialInstantiationOf(call, _, abs, constraint, _, _)
+      potentialInstantiationOf(call, _, abs, constraint, _)
     }
 
     predicate relevantTypeMention(FunctionType constraint) {