Rust: Make Call class part of the AST type hierarchy

Author: hvitved

rust/ql/lib/codeql/rust/controlflow/CfgNodes.qll

@@ -238,7 +238,7 @@ final class CallCfgNode extends ExprCfgNode {
 
   /** Gets the receiver of this call if it is a method call. */
   ExprCfgNode getReceiver() {
-    any(ChildMapping mapping).hasCfgChild(node, node.getReceiver(), this, result)
+    any(ChildMapping mapping).hasCfgChild(node, node.getReceiverArgument(), this, result)
   }
 
   /** Gets the `i`th argument of this call, if any. */

rust/ql/lib/codeql/rust/dataflow/internal/DataFlowImpl.qll

@@ -136,27 +136,16 @@ final class ArgumentPosition extends TArgumentPosition {
   /** Gets the argument of `call` at this position, if any. */
   Expr getArgument(Call call) {
     this.isReceiver() and
-    (
-      result = call.(MethodCallExpr).getReceiver()
-      or
-      result = call.(Operation).getOperand(0)
-      or
-      result = call.(IndexExpr).getBase()
-    )
+    result = call.getReceiverArgument()
     or
-    exists(boolean inMethodCall, int pos | this.getPosition(inMethodCall) = pos |
-      result = call.(CallExpr).getArg(pos) and
+    exists(boolean inMethodCall, int pos |
+      this.getPosition(inMethodCall) = pos and
+      result = call.getPositionalArgument(pos)
+    |
+      call instanceof CallExpr and
       inMethodCall = false
       or
-      result = call.(MethodCallExpr).getArg(pos) and
-      inMethodCall = true
-      or
-      result = call.(Operation).getOperand(pos + 1) and
-      pos >= 0 and
-      inMethodCall = true
-      or
-      result = call.(IndexExpr).getIndex() and
-      pos = 0 and
+      (call instanceof MethodCallExpr or call instanceof Operation or call instanceof IndexExpr) and
       inMethodCall = true
     )
   }

rust/ql/lib/codeql/rust/elements/Call.qll

@@ -4,6 +4,4 @@
 
 private import internal.CallImpl
 
-final class ArgumentPosition = Impl::ArgumentPosition;
-
 final class Call = Impl::Call;

rust/ql/lib/codeql/rust/elements/internal/CallExprBaseImpl.qll

@@ -13,15 +13,15 @@ private import codeql.rust.elements.internal.generated.CallExprBase
 module Impl {
   private import rust
   private import codeql.rust.internal.TypeInference as TypeInference
+  private import codeql.rust.elements.internal.CallImpl::Impl as CallImpl
 
   // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
    * A function or method call expression. See `CallExpr` and `MethodCallExpr` for further details.
    */
-  class CallExprBase extends Generated::CallExprBase {
-    /** Gets the static target (function or tuple struct/variant) of this call, if any. */
-    final Addressable getStaticTarget() { result = TypeInference::resolveCallTarget(this) }
-
+  class CallExprBase extends Generated::CallExprBase, CallImpl::Call {
     override Expr getArg(int index) { result = this.getArgList().getArg(index) }
+
+    override Expr getPositionalArgument(int i) { result = this.getArg(i) }
   }
 }

rust/ql/lib/codeql/rust/elements/internal/CallImpl.qll

@@ -1,53 +1,27 @@
 private import rust
-private import codeql.rust.internal.PathResolution
 private import codeql.rust.internal.TypeInference as TypeInference
 private import codeql.rust.elements.internal.ExprImpl::Impl as ExprImpl
-private import codeql.rust.elements.Operation
 
 module Impl {
-  newtype TArgumentPosition =
-    TPositionalArgumentPosition(int i) {
-      i in [0 .. max([any(ParamList l).getNumberOfParams(), any(ArgList l).getNumberOfArgs()]) - 1]
-    } or
-    TSelfArgumentPosition()
-
-  /** An argument position in a call. */
-  class ArgumentPosition extends TArgumentPosition {
-    /** Gets the index of the argument in the call, if this is a positional argument. */
-    int asPosition() { this = TPositionalArgumentPosition(result) }
-
-    /** Holds if this call position is a self argument. */
-    predicate isSelf() { this instanceof TSelfArgumentPosition }
-
-    /** Gets a string representation of this argument position. */
-    string toString() {
-      result = this.asPosition().toString()
-      or
-      this.isSelf() and result = "self"
-    }
-  }
-
   /**
    * An expression that calls a function.
    *
-   * This class abstracts over the different ways in which a function can be
-   * called in Rust.
+   * Either a `CallExprBase`, an `Operation`, or an `IndexExpr`.
    */
   abstract class Call extends ExprImpl::Expr {
-    /** Gets the argument at the given position, if any. */
-    abstract Expr getArgument(ArgumentPosition pos);
-
-    /** Gets the number of arguments _excluding_ any `self` argument. */
-    int getNumberOfArguments() { result = count(this.getArgument(TPositionalArgumentPosition(_))) }
-
-    /** Gets the `i`th argument of this call, if any. */
-    Expr getPositionalArgument(int i) { result = this.getArgument(TPositionalArgumentPosition(i)) }
+    /** Gets the `i`th positional argument of this call, if any. */
+    Expr getPositionalArgument(int i) { none() }
 
-    /** Gets the receiver of this call if it is a method call. */
-    Expr getReceiver() { result = this.getArgument(TSelfArgumentPosition()) }
+    /**
+     * Gets the receiver of this call, if any.
+     *
+     * This is either an actual receiver of a method call, the first operand of an operation,
+     * or the base expression of an index expression.
+     */
+    Expr getReceiverArgument() { none() }
 
-    /** Gets the static target of this call, if any. */
-    Function getStaticTarget() { result = TypeInference::resolveCallTarget(this) }
+    /** Gets the static target (function or tuple struct/variant) of this call, if any. */
+    final Addressable getStaticTarget() { result = TypeInference::resolveCallTarget(this) }
 
     /** Gets a runtime target of this call, if any. */
     pragma[nomagic]
@@ -60,82 +34,4 @@ module Impl {
       )
     }
   }
-
-  private predicate callHasQualifier(CallExpr call, Path path, Path qualifier) {
-    path = call.getFunction().(PathExpr).getPath() and
-    qualifier = path.getQualifier()
-  }
-
-  /** Holds if the call expression dispatches to a method. */
-  private predicate callIsMethodCall(
-    CallExpr call, Path qualifier, string methodName, boolean selfIsRef
-  ) {
-    exists(Path path, Function f |
-      callHasQualifier(call, path, qualifier) and
-      f = resolvePath(path) and
-      path.getSegment().getIdentifier().getText() = methodName and
-      exists(SelfParam self |
-        self = f.getSelfParam() and
-        if self.isRef() then selfIsRef = true else selfIsRef = false
-      )
-    )
-  }
-
-  class CallExprCall extends Call instanceof CallExpr {
-    CallExprCall() { not callIsMethodCall(this, _, _, _) }
-
-    override Expr getArgument(ArgumentPosition pos) {
-      result = super.getArgList().getArg(pos.asPosition())
-    }
-  }
-
-  class CallExprMethodCall extends Call instanceof CallExpr {
-    string methodName;
-    boolean selfIsRef;
-
-    CallExprMethodCall() { callIsMethodCall(this, _, methodName, selfIsRef) }
-
-    /**
-     * Holds if this call must have an explicit borrow for the `self` argument,
-     * because the corresponding parameter is `&self`. Explicit borrows are not
-     * needed when using method call syntax.
-     */
-    predicate hasExplicitSelfBorrow() { selfIsRef = true }
-
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and result = super.getArgList().getArg(0)
-      or
-      result = super.getArgList().getArg(pos.asPosition() + 1)
-    }
-  }
-
-  private class MethodCallExprCall extends Call instanceof MethodCallExpr {
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and result = this.(MethodCallExpr).getReceiver()
-      or
-      result = super.getArgList().getArg(pos.asPosition())
-    }
-  }
-
-  private class OperatorCall extends Call instanceof Operation {
-    Trait trait;
-    string methodName;
-    int borrows;
-
-    OperatorCall() { super.isOverloaded(trait, methodName, borrows) }
-
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and result = super.getOperand(0)
-      or
-      pos.asPosition() = 0 and result = super.getOperand(1)
-    }
-  }
-
-  private class IndexCall extends Call instanceof IndexExpr {
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and result = super.getBase()
-      or
-      pos.asPosition() = 0 and result = super.getIndex()
-    }
-  }
 }

rust/ql/lib/codeql/rust/elements/internal/IndexExprImpl.qll

@@ -11,6 +11,8 @@ private import codeql.rust.elements.internal.generated.IndexExpr
  * be referenced directly.
  */
 module Impl {
+  private import codeql.rust.elements.internal.CallImpl::Impl as CallImpl
+
   // the following QLdoc is generated: if you need to edit it, do it in the schema file
   /**
    * An index expression. For example:
@@ -19,10 +21,14 @@ module Impl {
    * list[42] = 1;
    * ```
    */
-  class IndexExpr extends Generated::IndexExpr {
+  class IndexExpr extends Generated::IndexExpr, CallImpl::Call {
     override string toStringImpl() {
       result =
         this.getBase().toAbbreviatedString() + "[" + this.getIndex().toAbbreviatedString() + "]"
     }
+
+    override Expr getPositionalArgument(int i) { i = 0 and result = this.getIndex() }
+
+    override Expr getReceiverArgument() { result = this.getBase() }
   }
 }

rust/ql/lib/codeql/rust/elements/internal/MethodCallExprImpl.qll

@@ -39,7 +39,6 @@ module Impl {
       result = strictconcat(int i | | this.toStringPart(i) order by i)
     }
 
-    /** Gets the static target of this method call, if any. */
-    final Function getStaticTarget() { result = super.getStaticTarget() }
+    override Expr getReceiverArgument() { result = super.getReceiver() }
   }
 }

rust/ql/lib/codeql/rust/elements/internal/OperationImpl.qll

@@ -12,6 +12,8 @@ private import codeql.rust.elements.internal.ExprImpl::Impl as ExprImpl
  * be referenced directly.
  */
 module Impl {
+  private import codeql.rust.elements.internal.CallImpl::Impl as CallImpl
+
   /**
    * Holds if the operator `op` with arity `arity` is overloaded to a trait with
    * the canonical path `path` and the method name `method`, and if it borrows its
@@ -100,13 +102,17 @@ module Impl {
   /**
    * An operation, for example `&&`, `+=`, `!` or `*`.
    */
-  abstract class Operation extends ExprImpl::Expr {
+  abstract class Operation extends CallImpl::Call {
     /** Gets the operator name of this operation, if it exists. */
     abstract string getOperatorName();
 
     /** Gets the `n`th operand of this operation, if any. */
     abstract Expr getOperand(int n);
 
+    override Expr getPositionalArgument(int i) { result = this.getOperand(i + 1) and i >= 0 }
+
+    override Expr getReceiverArgument() { result = this.getOperand(0) }
+
     /**
      * Gets the number of operands of this operation.
      *

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

@@ -1368,10 +1368,15 @@ private module MethodResolution {
    *
    * [1]: https://doc.rust-lang.org/std/ops/trait.Index.html
    */
-  abstract class MethodCall extends Expr {
+  abstract class MethodCall extends Call {
     abstract predicate hasNameAndArity(string name, int arity);
 
-    abstract Expr getArgument(ArgumentPosition pos);
+    Expr getArgument(ArgumentPosition pos) {
+      result = this.getPositionalArgument(pos.asPosition())
+      or
+      pos.isSelf() and
+      result = this.getReceiverArgument()
+    }
 
     abstract predicate supportsAutoDerefAndBorrow();
 
@@ -1614,12 +1619,12 @@ private module MethodResolution {
 
     predicate receiverHasImplicitDeref(AstNode receiver) {
       exists(this.resolveCallTarget(_, ".ref", false)) and
-      receiver = this.getArgument(CallImpl::TSelfArgumentPosition())
+      receiver = this.getArgument(any(ArgumentPosition pos | pos.isSelf()))
     }
 
     predicate argumentHasImplicitBorrow(AstNode arg) {
       exists(this.resolveCallTarget(_, "", true)) and
-      arg = this.getArgument(CallImpl::TSelfArgumentPosition())
+      arg = this.getArgument(any(ArgumentPosition pos | pos.isSelf()))
     }
   }
 
@@ -1630,13 +1635,6 @@ private module MethodResolution {
       arity = super.getArgList().getNumberOfArgs()
     }
 
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and
-      result = MethodCallExpr.super.getReceiver()
-      or
-      result = super.getArgList().getArg(pos.asPosition())
-    }
-
     override predicate supportsAutoDerefAndBorrow() { any() }
 
     override Trait getTrait() { none() }
@@ -1649,14 +1647,6 @@ private module MethodResolution {
       arity = 1
     }
 
-    override Expr getArgument(ArgumentPosition pos) {
-      pos.isSelf() and
-      result = this.getBase()
-      or
-      pos.asPosition() = 0 and
-      result = this.getIndex()
-    }
-
     override predicate supportsAutoDerefAndBorrow() { any() }
 
     override Trait getTrait() { result.getCanonicalPath() = "core::ops::index::Index" }
@@ -1690,6 +1680,7 @@ private module MethodResolution {
       arity = this.getArgList().getNumberOfArgs() - 1
     }
 
+    // todo: comment
     override Expr getArgument(ArgumentPosition pos) {
       pos.isSelf() and
       result = this.getArg(0)
@@ -1714,8 +1705,6 @@ private module MethodResolution {
       arity = this.getNumberOfOperands() - 1
     }
 
-    override Expr getArgument(ArgumentPosition pos) { result = this.(Call).getArgument(pos) }
-
     private predicate implicitBorrowAt(ArgumentPosition pos) {
       exists(int borrows | this.isOverloaded(_, _, borrows) |
         pos.isSelf() and borrows >= 1

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

@@ -5,6 +5,28 @@ private import codeql.rust.internal.Type
 private import codeql.rust.internal.TypeMention
 private import codeql.rust.elements.Call
 
+private newtype TArgumentPosition =
+  TPositionalArgumentPosition(int i) {
+    i in [0 .. max([any(ParamList l).getNumberOfParams(), any(ArgList l).getNumberOfArgs()]) - 1]
+  } or
+  TSelfArgumentPosition()
+
+/** An argument position in a call. */
+class ArgumentPosition extends TArgumentPosition {
+  /** Gets the index of the argument in the call, if this is a positional argument. */
+  int asPosition() { this = TPositionalArgumentPosition(result) }
+
+  /** Holds if this call position is a self argument. */
+  predicate isSelf() { this instanceof TSelfArgumentPosition }
+
+  /** Gets a string representation of this argument position. */
+  string toString() {
+    result = this.asPosition().toString()
+    or
+    this.isSelf() and result = "self"
+  }
+}
+
 private newtype TFunctionPosition =
   TArgumentFunctionPosition(ArgumentPosition pos) or
   TReturnFunctionPosition()