C++: Rewrite flow test common to use inline expectation test module

jketema · jketema · commit aeb6293757b1 · 2023-05-23T16:34:41.000+02:00
This also rewrites all uses of flow test common to use `DataFlow::ConfigSig`.

Note that the removed deprecated aliases are 14 months old by now and, hence,
can be safely removed.
diff --git a/cpp/ql/test/TestUtilities/dataflow/FlowTestCommon.qll b/cpp/ql/test/TestUtilities/dataflow/FlowTestCommon.qll
@@ -16,18 +16,16 @@ private import semmle.code.cpp.ir.dataflow.DataFlow::DataFlow as IRDataFlow
 private import semmle.code.cpp.dataflow.DataFlow::DataFlow as AstDataFlow
 import TestUtilities.InlineExpectationsTest
 
-class IRFlowTest extends InlineExpectationsTest {
-  IRFlowTest() { this = "IRFlowTest" }
+module IRFlowTest<IRDataFlow::GlobalFlowSig Flow> implements TestSig {
+  string getARelevantTag() { result = "ir" }
 
-  override string getARelevantTag() { result = "ir" }
-
-  override predicate hasActualResult(Location location, string element, string tag, string value) {
-    exists(IRDataFlow::Node source, IRDataFlow::Node sink, IRDataFlow::Configuration conf, int n |
+  predicate hasActualResult(Location location, string element, string tag, string value) {
+    exists(IRDataFlow::Node source, IRDataFlow::Node sink, int n |
       tag = "ir" and
-      conf.hasFlow(source, sink) and
+      Flow::flow(source, sink) and
       n =
         strictcount(int line, int column |
-          conf.hasFlow(any(IRDataFlow::Node otherSource |
+          Flow::flow(any(IRDataFlow::Node otherSource |
               otherSource.hasLocationInfo(_, line, column, _, _)
             ), sink)
         ) and
@@ -47,20 +45,16 @@ class IRFlowTest extends InlineExpectationsTest {
   }
 }
 
-class AstFlowTest extends InlineExpectationsTest {
-  AstFlowTest() { this = "ASTFlowTest" }
-
-  override string getARelevantTag() { result = "ast" }
+module AstFlowTest<AstDataFlow::GlobalFlowSig Flow> implements TestSig {
+  string getARelevantTag() { result = "ast" }
 
-  override predicate hasActualResult(Location location, string element, string tag, string value) {
-    exists(
-      AstDataFlow::Node source, AstDataFlow::Node sink, AstDataFlow::Configuration conf, int n
-    |
+  predicate hasActualResult(Location location, string element, string tag, string value) {
+    exists(AstDataFlow::Node source, AstDataFlow::Node sink, int n |
       tag = "ast" and
-      conf.hasFlow(source, sink) and
+      Flow::flow(source, sink) and
       n =
         strictcount(int line, int column |
-          conf.hasFlow(any(AstDataFlow::Node otherSource |
+          Flow::flow(any(AstDataFlow::Node otherSource |
               otherSource.hasLocationInfo(_, line, column, _, _)
             ), sink)
         ) and
@@ -79,6 +73,3 @@ class AstFlowTest extends InlineExpectationsTest {
     )
   }
 }
-
-/** DEPRECATED: Alias for AstFlowTest */
-deprecated class ASTFlowTest = AstFlowTest;
diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test.expected b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test.expected
@@ -0,0 +1,2 @@
+failures
+testFailures
diff --git a/cpp/ql/test/library-tests/dataflow/dataflow-tests/test.ql b/cpp/ql/test/library-tests/dataflow/dataflow-tests/test.ql
@@ -16,10 +16,8 @@ module AstTest {
   }
 
   /** Common data flow configuration to be used by tests. */
-  class AstTestAllocationConfig extends DataFlow::Configuration {
-    AstTestAllocationConfig() { this = "ASTTestAllocationConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module AstTestAllocationConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
       or
       source.asParameter().getName().matches("source%")
@@ -32,18 +30,20 @@ module AstTest {
       exists(source.asUninitialized())
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call |
         call.getTarget().getName() = ["sink", "indirect_sink"] and
         sink.asExpr() = call.getAnArgument()
       )
     }
 
-    override predicate isBarrier(DataFlow::Node barrier) {
+    predicate isBarrier(DataFlow::Node barrier) {
       barrier.asExpr().(VariableAccess).getTarget().hasName("barrier") or
       barrier = DataFlow::BarrierGuard<testBarrierGuard/3>::getABarrierNode()
     }
   }
+
+  module AstFlow = DataFlow::Global<AstTestAllocationConfig>;
 }
 
 module IRTest {
@@ -67,10 +67,8 @@ module IRTest {
   }
 
   /** Common data flow configuration to be used by tests. */
-  class IRTestAllocationConfig extends DataFlow::Configuration {
-    IRTestAllocationConfig() { this = "IRTestAllocationConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module IRTestAllocationConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
       or
       source.asIndirectExpr(1).(FunctionCall).getTarget().getName() = "indirect_source"
@@ -82,7 +80,7 @@ module IRTest {
       exists(source.asUninitialized())
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call, Expr e | e = call.getAnArgument() |
         call.getTarget().getName() = "sink" and
         sink.asExpr() = e
@@ -92,7 +90,7 @@ module IRTest {
       )
     }
 
-    override predicate isBarrier(DataFlow::Node barrier) {
+    predicate isBarrier(DataFlow::Node barrier) {
       exists(Expr barrierExpr | barrierExpr in [barrier.asExpr(), barrier.asIndirectExpr()] |
         barrierExpr.(VariableAccess).getTarget().hasName("barrier")
       )
@@ -102,4 +100,8 @@ module IRTest {
       barrier = DataFlow::BarrierGuard<testBarrierGuard/3>::getAnIndirectBarrierNode()
     }
   }
+
+  module IRFlow = DataFlow::Global<IRTestAllocationConfig>;
 }
+
+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>
diff --git a/cpp/ql/test/library-tests/dataflow/fields/ASTConfiguration.qll b/cpp/ql/test/library-tests/dataflow/fields/ASTConfiguration.qll
@@ -1,10 +1,8 @@
 private import semmle.code.cpp.dataflow.DataFlow
 private import DataFlow
 
-class AstConf extends Configuration {
-  AstConf() { this = "ASTFieldFlowConf" }
-
-  override predicate isSource(Node src) {
+module AstConfig implements ConfigSig {
+  predicate isSource(Node src) {
     src.asExpr() instanceof NewExpr
     or
     src.asExpr().(Call).getTarget().hasName("user_input")
@@ -15,14 +13,14 @@ class AstConf extends Configuration {
     )
   }
 
-  override predicate isSink(Node sink) {
+  predicate isSink(Node sink) {
     exists(Call c |
       c.getTarget().hasName("sink") and
       c.getAnArgument() = sink.asExpr()
     )
   }
 
-  override predicate isAdditionalFlowStep(Node a, Node b) {
+  predicate isAdditionalFlowStep(Node a, Node b) {
     b.asPartialDefinition() =
       any(Call c | c.getTarget().hasName("insert") and c.getAnArgument() = a.asExpr())
           .getQualifier()
@@ -31,5 +29,4 @@ class AstConf extends Configuration {
   }
 }
 
-/** DEPRECATED: Alias for AstConf */
-deprecated class ASTConf = AstConf;
+module AstFlow = Global<AstConfig>;
diff --git a/cpp/ql/test/library-tests/dataflow/fields/IRConfiguration.qll b/cpp/ql/test/library-tests/dataflow/fields/IRConfiguration.qll
@@ -1,10 +1,8 @@
 private import semmle.code.cpp.ir.dataflow.DataFlow
 private import DataFlow
 
-class IRConf extends Configuration {
-  IRConf() { this = "IRFieldFlowConf" }
-
-  override predicate isSource(Node src) {
+module IRConfig implements ConfigSig {
+  predicate isSource(Node src) {
     src.asExpr() instanceof NewExpr
     or
     src.asExpr().(Call).getTarget().hasName("user_input")
@@ -15,18 +13,20 @@ class IRConf extends Configuration {
     )
   }
 
-  override predicate isSink(Node sink) {
+  predicate isSink(Node sink) {
     exists(Call c |
       c.getTarget().hasName("sink") and
       c.getAnArgument() = [sink.asExpr(), sink.asIndirectExpr(), sink.asConvertedExpr()]
     )
   }
 
-  override predicate isAdditionalFlowStep(Node a, Node b) {
+  predicate isAdditionalFlowStep(Node a, Node b) {
     b.asPartialDefinition() =
       any(Call c | c.getTarget().hasName("insert") and c.getAnArgument() = a.asExpr())
           .getQualifier()
     or
     b.asExpr().(AddressOfExpr).getOperand() = a.asExpr()
   }
 }
+
+module IRFlow = Global<IRConfig>;
diff --git a/cpp/ql/test/library-tests/dataflow/fields/flow.expected b/cpp/ql/test/library-tests/dataflow/fields/flow.expected
@@ -0,0 +1,2 @@
+failures
+testFailures
diff --git a/cpp/ql/test/library-tests/dataflow/fields/flow.ql b/cpp/ql/test/library-tests/dataflow/fields/flow.ql
@@ -1,9 +1,11 @@
 import TestUtilities.dataflow.FlowTestCommon
 
 module AstTest {
-  private import ASTConfiguration
+  import ASTConfiguration
 }
 
 module IRTest {
-  private import IRConfiguration
+  import IRConfiguration
 }
+
+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>
diff --git a/cpp/ql/test/library-tests/dataflow/fields/ir-path-flow.ql b/cpp/ql/test/library-tests/dataflow/fields/ir-path-flow.ql
@@ -4,8 +4,8 @@
 
 import semmle.code.cpp.ir.dataflow.DataFlow
 import IRConfiguration
-import DataFlow::PathGraph
+import IRFlow::PathGraph
 
-from DataFlow::PathNode src, DataFlow::PathNode sink, IRConf conf
-where conf.hasFlowPath(src, sink)
+from IRFlow::PathNode src, IRFlow::PathNode sink
+where IRFlow::flowPath(src, sink)
 select sink, src, sink, sink + " flows from $@", src, src.toString()
diff --git a/cpp/ql/test/library-tests/dataflow/fields/path-flow.ql b/cpp/ql/test/library-tests/dataflow/fields/path-flow.ql
@@ -4,8 +4,8 @@
 
 import semmle.code.cpp.dataflow.DataFlow
 import ASTConfiguration
-import DataFlow::PathGraph
+import AstFlow::PathGraph
 
-from DataFlow::PathNode src, DataFlow::PathNode sink, AstConf conf
-where conf.hasFlowPath(src, sink)
+from AstFlow::PathNode src, AstFlow::PathNode sink
+where AstFlow::flowPath(src, sink)
 select sink, src, sink, sink + " flows from $@", src, src.toString()
diff --git a/cpp/ql/test/library-tests/dataflow/smart-pointers-taint/taint.expected b/cpp/ql/test/library-tests/dataflow/smart-pointers-taint/taint.expected
@@ -0,0 +1,2 @@
+failures
+testFailures
diff --git a/cpp/ql/test/library-tests/dataflow/smart-pointers-taint/taint.ql b/cpp/ql/test/library-tests/dataflow/smart-pointers-taint/taint.ql
@@ -3,37 +3,39 @@ import TestUtilities.dataflow.FlowTestCommon
 module AstTest {
   private import semmle.code.cpp.dataflow.TaintTracking
 
-  class AstSmartPointerTaintConfig extends TaintTracking::Configuration {
-    AstSmartPointerTaintConfig() { this = "ASTSmartPointerTaintConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module AstSmartPointerTaintConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call |
         call.getTarget().getName() = "sink" and
         sink.asExpr() = call.getAnArgument()
       )
     }
   }
+
+  module AstFlow = TaintTracking::Global<AstSmartPointerTaintConfig>;
 }
 
 module IRTest {
   private import semmle.code.cpp.ir.dataflow.TaintTracking
 
-  class IRSmartPointerTaintConfig extends TaintTracking::Configuration {
-    IRSmartPointerTaintConfig() { this = "IRSmartPointerTaintConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module IRSmartPointerTaintConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call |
         call.getTarget().getName() = "sink" and
         sink.asExpr() = call.getAnArgument()
       )
     }
   }
+
+  module IRFlow = TaintTracking::Global<IRSmartPointerTaintConfig>;
 }
+
+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>
diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/taint.expected b/cpp/ql/test/library-tests/dataflow/taint-tests/taint.expected
@@ -0,0 +1,2 @@
+failures
+testFailures
diff --git a/cpp/ql/test/library-tests/dataflow/taint-tests/taint.ql b/cpp/ql/test/library-tests/dataflow/taint-tests/taint.ql
@@ -43,10 +43,8 @@ module AstTest {
   private import semmle.code.cpp.models.interfaces.Taint
 
   /** Common data flow configuration to be used by tests. */
-  class AstTestAllocationConfig extends TaintTracking::Configuration {
-    AstTestAllocationConfig() { this = "ASTTestAllocationConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module AstTestAllocationConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
       or
       source.asParameter().getName().matches("source%")
@@ -60,28 +58,28 @@ module AstTest {
       )
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call |
         call.getTarget().getName() = "sink" and
         sink.asExpr() = call.getAnArgument()
       )
     }
 
-    override predicate isSanitizer(DataFlow::Node barrier) {
+    predicate isBarrier(DataFlow::Node barrier) {
       barrier.asExpr().(VariableAccess).getTarget().hasName("sanitizer")
     }
   }
+
+  module AstFlow = TaintTracking::Global<AstTestAllocationConfig>;
 }
 
 module IRTest {
   private import semmle.code.cpp.ir.IR
   private import semmle.code.cpp.ir.dataflow.TaintTracking
 
   /** Common data flow configuration to be used by tests. */
-  class TestAllocationConfig extends TaintTracking::Configuration {
-    TestAllocationConfig() { this = "TestAllocationConfig" }
-
-    override predicate isSource(DataFlow::Node source) {
+  module TestAllocationConfig implements DataFlow::ConfigSig {
+    predicate isSource(DataFlow::Node source) {
       source.asExpr().(FunctionCall).getTarget().getName() = "source"
       or
       source.asIndirectExpr().(FunctionCall).getTarget().getName() = "source"
@@ -94,21 +92,25 @@ module IRTest {
       )
     }
 
-    override predicate isSink(DataFlow::Node sink) {
+    predicate isSink(DataFlow::Node sink) {
       exists(FunctionCall call |
         call.getTarget().getName() = "sink" and
         [sink.asExpr(), sink.asIndirectExpr()] = call.getAnArgument()
       )
     }
 
-    override predicate isSanitizer(DataFlow::Node barrier) {
+    predicate isBarrier(DataFlow::Node barrier) {
       barrier.asExpr().(VariableAccess).getTarget().hasName("sanitizer")
     }
 
-    override predicate allowImplicitRead(DataFlow::Node node, DataFlow::ContentSet c) {
+    predicate allowImplicitRead(DataFlow::Node node, DataFlow::ContentSet c) {
       // allow arbitrary reads at sinks
-      this.isSink(node) and
+      isSink(node) and
       c.(DataFlow::FieldContent).getField().getDeclaringType() = node.getType().getUnspecifiedType()
     }
   }
+
+  module IRFlow = TaintTracking::Global<TestAllocationConfig>;
 }
+
+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>

Original file line number	Diff line number	Diff line change
`@@ -16,10 +16,8 @@ module AstTest {`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`/** Common data flow configuration to be used by tests. */`
`19`		`- class AstTestAllocationConfig extends DataFlow::Configuration {`
`20`		`- AstTestAllocationConfig() { this = "ASTTestAllocationConfig" }`
`21`		`-`
`22`		`- override predicate isSource(DataFlow::Node source) {`
	`19`	`+ module AstTestAllocationConfig implements DataFlow::ConfigSig {`
	`20`	`+ predicate isSource(DataFlow::Node source) {`
`23`	`21`	`source.asExpr().(FunctionCall).getTarget().getName() = "source"`
`24`	`22`	`or`
`25`	`23`	`source.asParameter().getName().matches("source%")`
`@@ -32,18 +30,20 @@ module AstTest {`
`32`	`30`	`exists(source.asUninitialized())`
`33`	`31`	`}`
`34`	`32`
`35`		`- override predicate isSink(DataFlow::Node sink) {`
	`33`	`+ predicate isSink(DataFlow::Node sink) {`
`36`	`34`	`exists(FunctionCall call \|`
`37`	`35`	`call.getTarget().getName() = ["sink", "indirect_sink"] and`
`38`	`36`	`sink.asExpr() = call.getAnArgument()`
`39`	`37`	`)`
`40`	`38`	`}`
`41`	`39`
`42`		`- override predicate isBarrier(DataFlow::Node barrier) {`
	`40`	`+ predicate isBarrier(DataFlow::Node barrier) {`
`43`	`41`	`barrier.asExpr().(VariableAccess).getTarget().hasName("barrier") or`
`44`	`42`	`barrier = DataFlow::BarrierGuard<testBarrierGuard/3>::getABarrierNode()`
`45`	`43`	`}`
`46`	`44`	`}`
	`45`	`+`
	`46`	`+ module AstFlow = DataFlow::Global<AstTestAllocationConfig>;`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`module IRTest {`
`@@ -67,10 +67,8 @@ module IRTest {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/** Common data flow configuration to be used by tests. */`
`70`		`- class IRTestAllocationConfig extends DataFlow::Configuration {`
`71`		`- IRTestAllocationConfig() { this = "IRTestAllocationConfig" }`
`72`		`-`
`73`		`- override predicate isSource(DataFlow::Node source) {`
	`70`	`+ module IRTestAllocationConfig implements DataFlow::ConfigSig {`
	`71`	`+ predicate isSource(DataFlow::Node source) {`
`74`	`72`	`source.asExpr().(FunctionCall).getTarget().getName() = "source"`
`75`	`73`	`or`
`76`	`74`	`source.asIndirectExpr(1).(FunctionCall).getTarget().getName() = "indirect_source"`
`@@ -82,7 +80,7 @@ module IRTest {`
`82`	`80`	`exists(source.asUninitialized())`
`83`	`81`	`}`
`84`	`82`
`85`		`- override predicate isSink(DataFlow::Node sink) {`
	`83`	`+ predicate isSink(DataFlow::Node sink) {`
`86`	`84`	`exists(FunctionCall call, Expr e \| e = call.getAnArgument() \|`
`87`	`85`	`call.getTarget().getName() = "sink" and`
`88`	`86`	`sink.asExpr() = e`
`@@ -92,7 +90,7 @@ module IRTest {`
`92`	`90`	`)`
`93`	`91`	`}`
`94`	`92`
`95`		`- override predicate isBarrier(DataFlow::Node barrier) {`
	`93`	`+ predicate isBarrier(DataFlow::Node barrier) {`
`96`	`94`	`exists(Expr barrierExpr \| barrierExpr in [barrier.asExpr(), barrier.asIndirectExpr()] \|`
`97`	`95`	`barrierExpr.(VariableAccess).getTarget().hasName("barrier")`
`98`	`96`	`)`
`@@ -102,4 +100,8 @@ module IRTest {`
`102`	`100`	`barrier = DataFlow::BarrierGuard<testBarrierGuard/3>::getAnIndirectBarrierNode()`
`103`	`101`	`}`
`104`	`102`	`}`
	`103`	`+`
	`104`	`+ module IRFlow = DataFlow::Global<IRTestAllocationConfig>;`
`105`	`105`	`}`
	`106`	`+`
	`107`	`+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,8 @@`
`1`	`1`	`private import semmle.code.cpp.dataflow.DataFlow`
`2`	`2`	`private import DataFlow`
`3`	`3`
`4`		`-class AstConf extends Configuration {`
`5`		`- AstConf() { this = "ASTFieldFlowConf" }`
`6`		`-`
`7`		`- override predicate isSource(Node src) {`
	`4`	`+module AstConfig implements ConfigSig {`
	`5`	`+ predicate isSource(Node src) {`
`8`	`6`	`src.asExpr() instanceof NewExpr`
`9`	`7`	`or`
`10`	`8`	`src.asExpr().(Call).getTarget().hasName("user_input")`
`@@ -15,14 +13,14 @@ class AstConf extends Configuration {`
`15`	`13`	`)`
`16`	`14`	`}`
`17`	`15`
`18`		`- override predicate isSink(Node sink) {`
	`16`	`+ predicate isSink(Node sink) {`
`19`	`17`	`exists(Call c \|`
`20`	`18`	`c.getTarget().hasName("sink") and`
`21`	`19`	`c.getAnArgument() = sink.asExpr()`
`22`	`20`	`)`
`23`	`21`	`}`
`24`	`22`
`25`		`- override predicate isAdditionalFlowStep(Node a, Node b) {`
	`23`	`+ predicate isAdditionalFlowStep(Node a, Node b) {`
`26`	`24`	`b.asPartialDefinition() =`
`27`	`25`	`any(Call c \| c.getTarget().hasName("insert") and c.getAnArgument() = a.asExpr())`
`28`	`26`	`.getQualifier()`
`@@ -31,5 +29,4 @@ class AstConf extends Configuration {`
`31`	`29`	`}`
`32`	`30`	`}`
`33`	`31`
`34`		`-/** DEPRECATED: Alias for AstConf */`
`35`		`-deprecated class ASTConf = AstConf;`
	`32`	`+module AstFlow = Global<AstConfig>;`
Original file line number	Diff line number	Diff line change
`@@ -1,10 +1,8 @@`
`1`	`1`	`private import semmle.code.cpp.ir.dataflow.DataFlow`
`2`	`2`	`private import DataFlow`
`3`	`3`
`4`		`-class IRConf extends Configuration {`
`5`		`- IRConf() { this = "IRFieldFlowConf" }`
`6`		`-`
`7`		`- override predicate isSource(Node src) {`
	`4`	`+module IRConfig implements ConfigSig {`
	`5`	`+ predicate isSource(Node src) {`
`8`	`6`	`src.asExpr() instanceof NewExpr`
`9`	`7`	`or`
`10`	`8`	`src.asExpr().(Call).getTarget().hasName("user_input")`
`@@ -15,18 +13,20 @@ class IRConf extends Configuration {`
`15`	`13`	`)`
`16`	`14`	`}`
`17`	`15`
`18`		`- override predicate isSink(Node sink) {`
	`16`	`+ predicate isSink(Node sink) {`
`19`	`17`	`exists(Call c \|`
`20`	`18`	`c.getTarget().hasName("sink") and`
`21`	`19`	`c.getAnArgument() = [sink.asExpr(), sink.asIndirectExpr(), sink.asConvertedExpr()]`
`22`	`20`	`)`
`23`	`21`	`}`
`24`	`22`
`25`		`- override predicate isAdditionalFlowStep(Node a, Node b) {`
	`23`	`+ predicate isAdditionalFlowStep(Node a, Node b) {`
`26`	`24`	`b.asPartialDefinition() =`
`27`	`25`	`any(Call c \| c.getTarget().hasName("insert") and c.getAnArgument() = a.asExpr())`
`28`	`26`	`.getQualifier()`
`29`	`27`	`or`
`30`	`28`	`b.asExpr().(AddressOfExpr).getOperand() = a.asExpr()`
`31`	`29`	`}`
`32`	`30`	`}`
	`31`	`+`
	`32`	`+module IRFlow = Global<IRConfig>;`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,11 @@`
`1`	`1`	`import TestUtilities.dataflow.FlowTestCommon`
`2`	`2`
`3`	`3`	`module AstTest {`
`4`		`- private import ASTConfiguration`
	`4`	`+ import ASTConfiguration`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`module IRTest {`
`8`		`- private import IRConfiguration`
	`8`	`+ import IRConfiguration`
`9`	`9`	`}`
	`10`	`+`
	`11`	`+import MakeTest<MergeTests<AstFlowTest<AstTest::AstFlow>, IRFlowTest<IRTest::IRFlow>>>`