C++: Cleanup in preparation for adding access paths at sources and sinks (no test changes).

Author: MathiasVP

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowNodes.qll

@@ -1655,13 +1655,13 @@ abstract private class AbstractParameterNode extends Node {
    * Holds if this node represents an implicit `this` parameter, if it exists.
    */
   predicate isThis() { none() } // overridden by subclasses
-}
 
-abstract private class AbstractIndirectParameterNode extends AbstractParameterNode {
   /** Gets the indirection index of this parameter node. */
-  abstract int getIndirectionIndex();
+  int getIndirectionIndex() { none() }
 }
 
+abstract private class AbstractIndirectParameterNode extends AbstractParameterNode { }
+
 pragma[noinline]
 private predicate indirectParameterNodeHasArgumentIndexAndIndex(
   IndirectInstructionParameterNode node, int argumentIndex, int indirectionIndex
@@ -1725,7 +1725,9 @@ private class IndirectInstructionParameterNode extends AbstractIndirectParameter
   final override int getIndirectionIndex() { this.hasInstructionAndIndirectionIndex(init, result) }
 }
 
-abstract private class AbstractDirectParameterNode extends AbstractParameterNode { }
+abstract private class AbstractDirectParameterNode extends AbstractParameterNode {
+  override int getIndirectionIndex() { result = 0 }
+}
 
 /**
  * A non-indirect parameter node that is represented as an `Instruction`.
@@ -1796,6 +1798,8 @@ private class DirectBodyLessParameterNode extends AbstractExplicitParameterNode,
   }
 
   override Parameter getParameter() { result = p }
+
+  final override int getIndirectionIndex() { result = 0 }
 }
 
 private class IndirectBodyLessParameterNode extends AbstractIndirectParameterNode,

cpp/ql/lib/semmle/code/cpp/ir/dataflow/internal/DataFlowPrivate.qll

@@ -508,11 +508,31 @@ predicate isArgumentNode(ArgumentNode arg, DataFlowCall c, ArgumentPosition pos)
  * on parameters are also included.
  */
 abstract class ArgumentNode extends Node {
+  /**
+   * Holds if this argument occurs at the given position in the given call,
+   * and this call is represented in the source code.
+   * The instance argument is considered to have index `-1`.
+   */
+  predicate sourceArgumentOf(CallInstruction call, ArgumentPosition pos) { none() }
+
+  /**
+   * Holds if this argument occurs at the given position in the given call,
+   * and this call part of a summary.
+   * The instance argument is considered to have index `-1`.
+   */
+  predicate summaryArgumentOf(FlowSummaryImpl::Public::SummarizedCallable call, ArgumentPosition pos) {
+    none()
+  }
+
   /**
    * Holds if this argument occurs at the given position in the given call.
    * The instance argument is considered to have index `-1`.
    */
-  abstract predicate argumentOf(DataFlowCall call, ArgumentPosition pos);
+  final predicate argumentOf(DataFlowCall call, ArgumentPosition pos) {
+    this.sourceArgumentOf(call.asCallInstruction(), pos)
+    or
+    this.summaryArgumentOf(call.asSummaryCall(), pos)
+  }
 
   /** Gets the call in which this node is an argument. */
   DataFlowCall getCall() { this.argumentOf(result, _) }
@@ -527,16 +547,16 @@ private class PrimaryArgumentNode extends ArgumentNode, OperandNode {
 
   PrimaryArgumentNode() { exists(CallInstruction call | op = call.getAnArgumentOperand()) }
 
-  override predicate argumentOf(DataFlowCall call, ArgumentPosition pos) {
+  override predicate sourceArgumentOf(CallInstruction call, ArgumentPosition pos) {
     op = call.getArgumentOperand(pos.(DirectPosition).getArgumentIndex())
   }
 }
 
 private class SideEffectArgumentNode extends ArgumentNode, SideEffectOperandNode {
-  override predicate argumentOf(DataFlowCall dfCall, ArgumentPosition pos) {
+  override predicate sourceArgumentOf(CallInstruction c, ArgumentPosition pos) {
     exists(int indirectionIndex |
       pos = TIndirectionPosition(argumentIndex, pragma[only_bind_into](indirectionIndex)) and
-      this.getCallInstruction() = dfCall.asCallInstruction() and
+      this.getCallInstruction() = c and
       super.hasAddressOperandAndIndirectionIndex(arg, pragma[only_bind_into](indirectionIndex))
     )
   }
@@ -554,8 +574,10 @@ class SummaryArgumentNode extends ArgumentNode, FlowSummaryNode {
     FlowSummaryImpl::Private::summaryArgumentNode(call_.getReceiver(), this.getSummaryNode(), pos_)
   }
 
-  override predicate argumentOf(DataFlowCall call, ArgumentPosition pos) {
-    call = call_ and
+  override predicate summaryArgumentOf(
+    FlowSummaryImpl::Public::SummarizedCallable call, ArgumentPosition pos
+  ) {
+    call = call_.asSummaryCall() and
     pos = pos_
   }
 }
@@ -569,8 +591,8 @@ private class FlowSummaryArgumentNode extends ArgumentNode, FlowSummaryNode {
     this.getSummaryNode() = FlowSummaryImpl::Private::summaryArgumentNode(callInstruction, rk)
   }
 
-  override predicate argumentOf(DataFlowCall call, ArgumentPosition pos) {
-    call.asCallInstruction() = callInstruction and
+  override predicate sourceArgumentOf(CallInstruction call, ArgumentPosition pos) {
+    call = callInstruction and
     pos = TFlowSummaryPosition(rk)
   }
 }
@@ -593,6 +615,32 @@ abstract class Position extends TPosition {
 
   /** Gets the indirection index of this position. */
   abstract int getIndirectionIndex();
+
+  /**
+   * Gets the parameter associated with this position, if any.
+   *
+   * Since a `Position` is defined by both an argument index and an
+   * indirection multiple `Position`s can be associated with the
+   * same `Parameter`.
+   */
+  Parameter getParameter(Function f) {
+    result.getFunction() = f and
+    this.getArgumentIndex() = result.getIndex()
+  }
+
+  /**
+   * Gets the argument (or qualifier) associated with this position, if any.
+   *
+   * Since a `Position` is defined by both an argument index and an
+   * indirection multiple `Position`s can be associated with the
+   * same argument/qualifier.
+   */
+  Expr getArgument(Cpp::Call call) {
+    result = call.getArgument(this.getArgumentIndex())
+    or
+    this.getArgumentIndex() = -1 and
+    result = call.getQualifier()
+  }
 }
 
 class DirectPosition extends Position, TDirectPosition {
@@ -1189,6 +1237,11 @@ class DataFlowCall extends TDataFlowCall {
    */
   CallInstruction asCallInstruction() { none() }
 
+  /**
+   * Gets the underlying summarized call, if any.
+   */
+  FlowSummaryImpl::Public::SummarizedCallable asSummaryCall() { none() }
+
   /**
    * Gets the operand the specifies the target function of the call.
    */
@@ -1306,6 +1359,8 @@ class SummaryCall extends DataFlowCall, TSummaryCall {
    */
   FlowSummaryImpl::Private::SummaryNode getReceiver() { result = receiver }
 
+  final override FlowSummaryImpl::Public::SummarizedCallable asSummaryCall() { result = c }
+
   // no implementation for `getCallTargetOperand()`, `getStaticCallTarget()`
   // or `getArgumentOperand(int index)`. This is because the flow summary
   // library is responsible for finding the call target, and there are no