C#: Define discarding predicates for expressions, statements, locations and some named TRAP entities.

Author: michaelnebel

csharp/ql/lib/csharp.qll

@@ -36,6 +36,7 @@ import semmle.code.csharp.controlflow.ControlFlowGraph
 import semmle.code.csharp.dataflow.DataFlow
 import semmle.code.csharp.dataflow.TaintTracking
 import semmle.code.csharp.dataflow.SSA
+private import semmle.code.csharp.Overlay
 
 /** Whether the source was extracted without a build command. */
 predicate extractionIsStandalone() { exists(SourceFile f | f.extractedStandalone()) }

csharp/ql/lib/semmle/code/csharp/Overlay.qll

@@ -0,0 +1,101 @@
+/**
+ * Defines entity discard predicates for C# overlay analysis.
+ */
+
+/**
+ * Holds always for the overlay variant and never for the base variant.
+ * This local predicate is used to define local predicates that behave
+ * differently for the base and overlay variant.
+ */
+overlay[local]
+predicate isOverlay() { databaseMetadata("isOverlay", "true") }
+
+/**
+ * An abstract base class for all elements that can be discarded from the base.
+ */
+overlay[local]
+abstract private class DiscardableEntity extends @element {
+  /** Gets the path to the file in which this element occurs. */
+  abstract string getPath();
+
+  /** Holds if this element exists in the base variant. */
+  predicate existsInBase() { not isOverlay() and exists(this) }
+
+  /** Holds if this element exists in the overlay variant. */
+  predicate existsInOverlay() { isOverlay() and exists(this) }
+
+  /** Gets a textual representation of this discardable element. */
+  string toString() { none() }
+}
+
+/**
+ * A class of C# database entities that use `*` IDs.
+ * The rest use named TRAP IDs.
+ */
+overlay[local]
+private class StarEntity = @expr or @stmt;
+
+overlay[discard_entity]
+private predicate discardStarEntity(@element e) {
+  e instanceof StarEntity and
+  // Entities with *-ids can exist either in base or overlay, but not both.
+  exists(DiscardableEntity de | de = e |
+    overlayChangedFiles(de.getPath()) and
+    de.existsInBase()
+  )
+}
+
+overlay[discard_entity]
+private predicate discardNamedEntity(@element e) {
+  not e instanceof StarEntity and
+  // Entities with named IDs can exist both in base, overlay, or both.
+  exists(DiscardableEntity de | de = e |
+    overlayChangedFiles(de.getPath()) and
+    not de.existsInOverlay()
+  )
+}
+
+overlay[local]
+private string getLocationPath(@location_default loc) {
+  exists(@file file | locations_default(loc, file, _, _, _, _) | files(file, result))
+}
+
+overlay[local]
+private predicate discardableLocation(@location_default loc, string path) {
+  not isOverlay() and
+  path = getLocationPath(loc)
+}
+
+// Discard locations that are in changed files from the base variant.
+overlay[discard_entity]
+private predicate discardLocation(@location_default loc) {
+  exists(string path | discardableLocation(loc, path) | overlayChangedFiles(path))
+}
+
+overlay[local]
+private class ExprEntity extends DiscardableEntity instanceof @expr {
+  override string getPath() {
+    exists(@location_default loc | expr_location(this, loc) | result = getLocationPath(loc))
+  }
+}
+
+overlay[local]
+private class StmtEntity extends DiscardableEntity instanceof @stmt {
+  override string getPath() {
+    exists(@location_default loc | stmt_location(this, loc) | result = getLocationPath(loc))
+  }
+}
+
+overlay[local]
+private class TypeEntity extends DiscardableEntity instanceof @type {
+  override string getPath() {
+    exists(@location_default loc | type_location(this, loc) | result = getLocationPath(loc))
+  }
+}
+
+overlay[local]
+private class MethodEntity extends DiscardableEntity instanceof @method {
+  override string getPath() {
+    exists(@location_default loc | method_location(this, loc) | result = getLocationPath(loc))
+  }
+}