Rust: Improve performance maybe

paldepind · paldepind · commit fd51708b17fc · 2025-08-31T17:23:22.000+02:00
diff --git a/rust/ql/lib/codeql/rust/internal/PathResolution.qll b/rust/ql/lib/codeql/rust/internal/PathResolution.qll
@@ -240,12 +240,7 @@ abstract class ItemNode extends Locatable {
       )
     or
     // items made available by an implementation where `this` is the implementing type
-    exists(ItemNode node |
-      this = node.(ImplItemNodeImpl).resolveSelfTyCand() and
-      result = node.getASuccessor(name, kind) and
-      kind.isExternalOrBoth() and
-      result instanceof AssocItemNode
-    )
+    typeImplEdge(this, _, name, kind, result)
     or
     // trait items with default implementations made available in an implementation
     exists(ImplItemNodeImpl impl, ItemNode trait |
@@ -1422,10 +1417,33 @@ private ItemNode unqualifiedPathLookup(RelevantPath p, Namespace ns, SuccessorKi
 pragma[nomagic]
 private predicate isUnqualifiedSelfPath(RelevantPath path) { path.isUnqualified("Self") }
 
-/** Holds if the trait `trait` is visible at the element `element`. */
-bindingset[element, trait]
-predicate traitIsVisible(Element element, TraitItemNode trait) {
-  exists(ItemNode encl | encl.getADescendant*() = element and trait = encl.getASuccessor(_, _))
+/** Provides the input to `TraitIsVisible`. */
+signature predicate relevantTraitVisibleSig(Element element, Trait trait);
+
+/**
+ * Provides the `traitIsVisible` predicate for determining if a trait is visible
+ * at a given element.
+ */
+module TraitIsVisible<relevantTraitVisibleSig/2 relevantTraitVisible> {
+  /** Holds if the trait might be looked up in `encl`. */
+  private predicate traitLookup(ItemNode encl, Element element, Trait trait) {
+    // lookup in immediately enclosing item
+    relevantTraitVisible(element, trait) and
+    encl.getADescendant() = element
+    or
+    // lookup in an outer scope, but only if the trait is not declared in inner scope
+    exists(ItemNode mid |
+      traitLookup(mid, element, trait) and
+      not trait = mid.getASuccessor(_, _) and
+      encl = getOuterScope(mid)
+    )
+  }
+
+  /** Holds if the trait `trait` is visible at `element`. */
+  pragma[nomagic]
+  predicate traitIsVisible(Element element, Trait trait) {
+    exists(ItemNode encl | traitLookup(encl, element, trait) and trait = encl.getASuccessor(_, _))
+  }
 }
 
 pragma[nomagic]
@@ -1453,14 +1471,6 @@ private ItemNode resolvePathCandQualifier(RelevantPath qualifier, RelevantPath p
   name = path.getText()
 }
 
-pragma[nomagic]
-private TraitItemNode assocItemImplementsTrait(AssocItemNode assoc) {
-  exists(ImplItemNodeImpl impl |
-    impl.getAnAssocItem() = assoc and
-    result = impl.resolveTraitTyCand()
-  )
-}
-
 /**
  * Gets the item that `path` resolves to in `ns` when `qualifier` is the
  * qualifier of `path` and `qualifier` resolves to `q`, if any.
@@ -1539,6 +1549,19 @@ private ItemNode resolvePathCand(RelevantPath path) {
   )
 }
 
+/** Get a trait that should be visible when `path` resolves to `node`, if any. */
+private Trait getResolvePathTraitUsed(RelevantPath path, AssocItemNode node) {
+  exists(TypeItemNode type, ImplItemNodeImpl impl |
+    node = resolvePathCandQualified(_, type, path, _) and
+    typeImplEdge(type, impl, _, _, node) and
+    result = impl.resolveTraitTyCand()
+  )
+}
+
+private predicate pathTraitUsed(Element path, Trait trait) {
+  trait = getResolvePathTraitUsed(path, _)
+}
+
 /** Gets the item that `path` resolves to, if any. */
 cached
 ItemNode resolvePath(RelevantPath path) {
@@ -1547,9 +1570,9 @@ ItemNode resolvePath(RelevantPath path) {
   (
     // When the result is an associated item of a trait implementation the
     // implemented trait must be visible.
-    traitIsVisible(path, assocItemImplementsTrait(pragma[only_bind_out](result)))
+    TraitIsVisible<pathTraitUsed/2>::traitIsVisible(path, getResolvePathTraitUsed(path, result))
     or
-    not exists(ImplItemNode impl | impl.getAnAssocItem() = result and impl.(Impl).hasTrait())
+    not exists(getResolvePathTraitUsed(path, result))
   )
   or
   // if `path` is the qualifier of a resolvable `parent`, then we should
@@ -1663,6 +1686,18 @@ private predicate externCrateEdge(ExternCrateItemNode ec, string name, CrateItem
   )
 }
 
+/**
+ * Holds if `typeItem` is the implementing type of `impl` and the implementation
+ * makes `assoc` available as `name` at `kind`.
+ */
+private predicate typeImplEdge(
+  TypeItemNode typeItem, ImplItemNodeImpl impl, string name, SuccessorKind kind, AssocItemNode assoc
+) {
+  typeItem = impl.resolveSelfTyCand() and
+  assoc = impl.getASuccessor(name, kind) and
+  kind.isExternalOrBoth()
+}
+
 pragma[nomagic]
 private predicate preludeItem(string name, ItemNode i) {
   exists(Crate stdOrCore, ModuleLikeNode mod, ModuleItemNode prelude, ModuleItemNode rust |
diff --git a/rust/ql/lib/codeql/rust/internal/TypeInference.qll b/rust/ql/lib/codeql/rust/internal/TypeInference.qll
@@ -1885,16 +1885,6 @@ private predicate methodCandidate(Type type, string name, int arity, Impl impl)
   )
 }
 
-/**
- * Holds if a method for `type` for `trait` with the name `name` and the arity
- * `arity` exists in `impl`.
- */
-pragma[nomagic]
-private predicate methodCandidateTrait(Type type, Trait trait, string name, int arity, Impl impl) {
-  trait = impl.(ImplItemNode).resolveTraitTy() and
-  methodCandidate(type, name, arity, impl)
-}
-
 pragma[nomagic]
 private predicate isMethodCall(MethodCall mc, Type rootType, string name, int arity) {
   rootType = mc.getTypeAt(TypePath::nil()) and
@@ -1903,21 +1893,35 @@ private predicate isMethodCall(MethodCall mc, Type rootType, string name, int ar
 }
 
 private module IsInstantiationOfInput implements IsInstantiationOfInputSig<MethodCall> {
-  pragma[nomagic]
-  predicate potentialInstantiationOf(MethodCall mc, TypeAbstraction impl, TypeMention constraint) {
+  private predicate methodCallMethodCandidate(MethodCall mc, Impl impl) {
     exists(Type rootType, string name, int arity |
       isMethodCall(mc, rootType, name, arity) and
-      constraint = impl.(ImplTypeAbstraction).getSelfTy()
+      methodCandidate(rootType, name, arity, impl)
+    )
+  }
+
+  private predicate relevantTraitVisible(Element mc, Trait trait) {
+    not exists(mc.(MethodCall).getTrait()) and
+    trait = any(ImplItemNode impl | methodCallMethodCandidate(mc, impl)).resolveTraitTy()
+  }
+
+  pragma[nomagic]
+  predicate potentialInstantiationOf(MethodCall mc, TypeAbstraction abs, TypeMention constraint) {
+    exists(ImplItemNode impl |
+      impl = abs and
+      methodCallMethodCandidate(mc, impl) and
+      constraint = impl.(Impl).getSelfTy()
     |
-      methodCandidateTrait(rootType, mc.getTrait(), name, arity, impl)
+      not exists(impl.resolveTraitTy())
       or
-      not exists(mc.getTrait()) and
-      methodCandidate(rootType, name, arity, impl) and
-      (
-        traitIsVisible(mc, impl.(ImplItemNode).resolveTraitTy())
-        or
-        not exists(impl.(ImplItemNode).resolveTraitTy())
-      )
+      // If the method call has a trait, the trait is mentioned fully qualified
+      // and need not be visible.
+      impl.resolveTraitTy() = mc.getTrait()
+      or
+      // If the `impl` block implements a trait, that trait must be visible in
+      // order for the `impl` to be valid.
+      TraitIsVisible<relevantTraitVisible/2>::traitIsVisible(mc,
+        pragma[only_bind_into](impl.resolveTraitTy()))
     )
   }
 
