Rust: Include more calls in DB quality metrics

Author: hvitved

rust/ql/consistency-queries/PathResolutionConsistency.ql

@@ -15,8 +15,8 @@ class SourceLocatable extends Locatable {
   SourceLocatable() { this.fromSource() }
 }
 
-query predicate multipleCallTargets(SourceLocatable a) {
-  PathResolutionConsistency::multipleCallTargets(a, _)
+query predicate multipleResolvedTargets(SourceLocatable a) {
+  PathResolutionConsistency::multipleResolvedTargets(a, _)
 }
 
 query predicate multiplePathResolutions(SourceLocatable a) {

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

@@ -24,17 +24,10 @@ query predicate multiplePathResolutions(Path p, ItemNode i) {
   strictcount(ItemNode i0 | i0 = resolvePath(p) and not i0 instanceof Crate) > 1
 }
 
-// TODO: Take other calls into account
-abstract private class CallExprBase extends ArgsExpr { }
-
-private class CallExprCallExprBase extends CallExpr, CallExprBase { }
-
-private class MethodCallExprCallExprBase extends MethodCallExpr, CallExprBase { }
-
-/** Holds if `call` has multiple static call targets including `target`. */
-query predicate multipleCallTargets(CallExprBase call, Callable target) {
-  target = call.getResolvedTarget() and
-  strictcount(call.getResolvedTarget()) > 1
+/** Holds if `ae` has multiple resolved targets including `target`. */
+query predicate multipleResolvedTargets(ArgsExpr ae, Addressable target) {
+  target = ae.getResolvedTarget() and
+  strictcount(ae.getResolvedTarget()) > 1
 }
 
 /** Holds if `fe` resolves to multiple record fields including `field`. */
@@ -62,8 +55,8 @@ int getPathResolutionInconsistencyCounts(string type) {
   type = "Multiple path resolutions" and
   result = count(Path p | multiplePathResolutions(p, _) | p)
   or
-  type = "Multiple static call targets" and
-  result = count(CallExprBase call | multipleCallTargets(call, _) | call)
+  type = "Multiple resolved targets" and
+  result = count(ArgsExpr ae | multipleResolvedTargets(ae, _) | ae)
   or
   type = "Multiple record fields" and
   result = count(FieldExpr fe | multipleStructFields(fe, _) | fe)

rust/ql/src/queries/telemetry/DatabaseQuality.qll

@@ -19,25 +19,25 @@ private class RelevantFile extends File {
 }
 
 module CallTargetStats implements StatsSig {
-  // TODO: Take other calls into account
-  abstract private class CallExprBase extends ArgsExpr { }
-
-  private class CallExprCallExprBase extends CallExpr, CallExprBase { }
-
-  private class MethodCallExprCallExprBase extends MethodCallExpr, CallExprBase { }
-
-  int getNumberOfOk() {
-    result =
-      count(CallExprBase c | c.getFile() instanceof RelevantFile and exists(c.getResolvedTarget()))
+  /**
+   * A call-like expression that is relevant for call target statistics.
+   *
+   * Note that this also includes tuple struct instantiations and tuple
+   * enum variant instantiations.
+   */
+  private class RelevantArgsExpr extends ArgsExpr {
+    RelevantArgsExpr() {
+      this.getFile() instanceof RelevantFile and
+      not this instanceof ClosureCallExpr and
+      not this = any(Operation o | not o.isOverloaded(_, _, _))
+    }
   }
 
-  additional predicate isNotOkCall(CallExprBase c) {
-    c.getFile() instanceof RelevantFile and
-    not exists(c.getResolvedTarget()) and
-    not c instanceof ClosureCallExpr
-  }
+  int getNumberOfOk() { result = count(RelevantArgsExpr e | exists(e.getResolvedTarget())) }
+
+  additional predicate isNotOkCall(RelevantArgsExpr e) { not exists(e.getResolvedTarget()) }
 
-  int getNumberOfNotOk() { result = count(CallExprBase c | isNotOkCall(c)) }
+  int getNumberOfNotOk() { result = count(RelevantArgsExpr e | isNotOkCall(e)) }
 
   string getOkText() { result = "calls with call target" }