Python: Reword comment on isBarrierIn

yoff · yoff · commit 9ee5a01d7e54 · 2020-10-21T10:30:40.000+02:00
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting1.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting1.ql
@@ -32,8 +32,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting2.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting2.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting3.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting3.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting4.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting4.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting5.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting5.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting6.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting6.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }
diff --git a/python/ql/test/experimental/dataflow/coverage/argumentRouting7.ql b/python/ql/test/experimental/dataflow/coverage/argumentRouting7.ql
@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {
   }
 
   /**
-   * This prevents the argument from one call to reach the sink
-   * via a different call, by flowing to an argument of that.
+   * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
+   * Use-use flow lets the argument to the first call reach the sink inside the second call,
+   * making it seem like we handle all cases even if we only handle the last one.
+   * We make the test honest by preventing flow into source nodes.
    */
   override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }
 }

Original file line number	Diff line number	Diff line change
`@@ -32,8 +32,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/**`
`35`		`- * This prevents the argument from one call to reach the sink`
`36`		`- * via a different call, by flowing to an argument of that.`
	`35`	+ * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
	`36`	`+ * Use-use flow lets the argument to the first call reach the sink inside the second call,`
	`37`	`+ * making it seem like we handle all cases even if we only handle the last one.`
	`38`	`+ * We make the test honest by preventing flow into source nodes.`
`37`	`39`	`*/`
`38`	`40`	`override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }`
`39`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,10 @@ class ArgumentRoutingConfig extends DataFlow::Configuration {`
`24`	`24`	`}`
`25`	`25`
`26`	`26`	`/**`
`27`		`- * This prevents the argument from one call to reach the sink`
`28`		`- * via a different call, by flowing to an argument of that.`
	`27`	+ * We want to be able to use `arg` in a sequence of calls such as `func(kw=arg); ... ; func(arg)`.
	`28`	`+ * Use-use flow lets the argument to the first call reach the sink inside the second call,`
	`29`	`+ * making it seem like we handle all cases even if we only handle the last one.`
	`30`	`+ * We make the test honest by preventing flow into source nodes.`
`29`	`31`	`*/`
`30`	`32`	`override predicate isBarrierIn(DataFlow::Node node) { isSource(node) }`
`31`	`33`	`}`