Python: Adapt to FlowSummaryImpl changes

Author: hvitved

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowDispatch.qll

@@ -1711,21 +1711,12 @@ class FlowSummaryNode extends Node, TFlowSummaryNode {
   }
 
   override DataFlowCallable getEnclosingCallable() {
-    result.asLibraryCallable() = this.getSummarizedCallable()
+    result = this.getSummaryNode().getEnclosingCallable()
   }
 
   override string toString() { result = this.getSummaryNode().toString() }
 
-  // Hack to return "empty location"
-  deprecated override predicate hasLocationInfo(
-    string file, int startline, int startcolumn, int endline, int endcolumn
-  ) {
-    file = "" and
-    startline = 0 and
-    startcolumn = 0 and
-    endline = 0 and
-    endcolumn = 0
-  }
+  override Location getLocation() { result = this.getSummaryNode().getLocation() }
 }
 
 private class SummaryReturnNode extends FlowSummaryNode, ReturnNode {

python/ql/lib/semmle/python/dataflow/new/internal/DataFlowPrivate.qll

@@ -529,8 +529,7 @@ predicate simpleLocalFlowStepForTypetracking(Node nodeFrom, Node nodeTo) {
 }
 
 private predicate summaryLocalStep(Node nodeFrom, Node nodeTo, string model) {
-  FlowSummaryImpl::Private::Steps::summaryLocalStep(nodeFrom,
-    nodeTo.(FlowSummaryNode).getSummaryNode(), true, model)
+  FlowSummaryImpl::Private::Steps::summaryLocalStep(nodeFrom, nodeTo, true, model)
 }
 
 predicate variableCaptureLocalFlowStep(Node nodeFrom, Node nodeTo) {
@@ -697,8 +696,7 @@ predicate jumpStep(Node nodeFrom, Node nodeTo) {
   or
   jumpStepNotSharedWithTypeTracker(nodeFrom, nodeTo)
   or
-  FlowSummaryImpl::Private::Steps::summaryJumpStep(nodeFrom.(FlowSummaryNode).getSummaryNode(),
-    nodeTo.(FlowSummaryNode).getSummaryNode())
+  FlowSummaryImpl::Private::Steps::summaryJumpStep(nodeFrom, nodeTo)
 }
 
 /**

python/ql/lib/semmle/python/dataflow/new/internal/FlowSummaryImpl.qll

@@ -14,16 +14,27 @@ private import DataFlowImplSpecific::Public
 module Input implements InputSig<Location, DataFlowImplSpecific::PythonDataFlow> {
   private import codeql.util.Void
 
-  class SummarizedCallableBase = string;
+  class SummarizedCallableBase extends string {
+    bindingset[this]
+    SummarizedCallableBase() { exists(this) }
 
-  class SourceBase = Void;
+    Location getLocation() { none() }
+  }
+
+  class SourceBase extends Void {
+    Location getLocation() { none() }
+  }
 
-  class SinkBase = Void;
+  class SinkBase = SourceBase;
 
-  class FlowSummaryCallBase = Void;
+  class FlowSummaryCallBase = SourceBase;
 
   predicate callableFromSource(SummarizedCallableBase c) { none() }
 
+  DataFlowCallable getSummarizedCallableAsDataFlowCallable(SummarizedCallableBase c) {
+    result.asLibraryCallable() = c
+  }
+
   ArgumentPosition callbackSelfParameterPosition() { result.isLambdaSelf() }
 
   ReturnKind getStandardReturnValueKind() { any() }
@@ -112,11 +123,47 @@ module Input implements InputSig<Location, DataFlowImplSpecific::PythonDataFlow>
 
 private import Make<Location, DataFlowImplSpecific::PythonDataFlow, Input> as Impl
 
-private module StepsInput implements Impl::Private::StepsInputSig {
-  Impl::Private::SummaryNode getSummaryNode(Node n) {
-    result = n.(FlowSummaryNode).getSummaryNode()
+private module Input2 implements Impl::Private::InputSig2 {
+  private import codeql.util.Void
+
+  class SourceSinkReportingElement extends Void {
+    Location getLocation() { none() }
+
+    DataFlowCallable getEnclosingCallable() { none() }
+  }
+
+  SourceSinkReportingElement getSourceEntryElement(
+    Impl::Public::SourceElement source, Impl::Private::SummaryComponent sc
+  ) {
+    none()
+  }
+
+  SourceSinkReportingElement getNextElement(
+    SourceSinkReportingElement prev, Impl::Private::SummaryComponent sc
+  ) {
+    none()
   }
 
+  bindingset[e, sc]
+  Node getSourceExitNode(SourceSinkReportingElement e, Impl::Private::SummaryComponent sc) {
+    none()
+  }
+
+  SourceSinkReportingElement getSinkExitElement(
+    Impl::Public::SinkElement sink, Impl::Private::SummaryComponent sc
+  ) {
+    none()
+  }
+
+  bindingset[e, sc]
+  Node getSinkEntryNode(SourceSinkReportingElement e, Impl::Private::SummaryComponent sc) { none() }
+}
+
+private import Impl::Private::Make2<Input2> as Impl2
+
+private module StepsInput implements Impl2::StepsInputSig {
+  Impl2::SummaryNode getSummaryNode(Node n) { result = n.(FlowSummaryNode).getSummaryNode() }
+
   overlay[global]
   DataFlowCall getACall(Public::SummarizedCallable sc) {
     result =
@@ -125,18 +172,13 @@ private module StepsInput implements Impl::Private::StepsInputSig {
           sc.(LibraryCallable).getACallSimple().asCfgNode()
         ])
   }
-
-  DataFlowCallable getSourceNodeEnclosingCallable(Input::SourceBase source) { none() }
-
-  Node getSourceNode(Input::SourceBase source, Impl::Private::SummaryComponentStack s) { none() }
-
-  Node getSinkNode(Input::SinkBase sink, Impl::Private::SummaryComponent sc) { none() }
 }
 
 module Private {
   import Impl::Private
+  import Impl2
 
-  module Steps = Impl::Private::Steps<StepsInput>;
+  module Steps = Impl2::Steps<StepsInput>;
 
   /**
    * Provides predicates for constructing summary components.

python/ql/lib/semmle/python/dataflow/new/internal/TaintTrackingPrivate.qll

@@ -80,8 +80,7 @@ private module Cached {
     ) and
     model = ""
     or
-    FlowSummaryImpl::Private::Steps::summaryLocalStep(nodeFrom,
-      nodeTo.(DataFlowPrivate::FlowSummaryNode).getSummaryNode(), false, model)
+    FlowSummaryImpl::Private::Steps::summaryLocalStep(nodeFrom, nodeTo, false, model)
   }
 }