Overlay.qll: Streamline discarding

- Unify discardable entities under one Discardable superclass.
- Reduce discard predicates down to two depending on TRAP ID type.

Author: d10c

python/ql/lib/semmle/python/Overlay.qll

@@ -14,30 +14,54 @@ overlay[local]
 predicate isOverlay() { databaseMetadata("isOverlay", "true") }
 
 overlay[local]
-private string getRawPathForLocation(@location loc) {
+private string getPathForLocation(@location loc) {
   exists(@file file | locations_default(loc, file, _, _, _, _) | files(file, result))
   or
-  exists(@py_Module mod | locations_ast(loc, mod, _, _, _, _) | result = getRawPathForModule(mod))
+  exists(@py_Module mod | locations_ast(loc, mod, _, _, _, _) | result = getPathForModule(mod))
 }
 
 overlay[local]
-private string getRawPathForModule(@py_Module mod) {
+private string getPathForModule(@py_Module mod) {
   exists(@container fileOrFolder | py_module_path(mod, fileOrFolder) |
-    result = getRawPathForContainer(fileOrFolder)
+    result = getPathForContainer(fileOrFolder)
   )
 }
 
 overlay[local]
-private string getRawPathForContainer(@container fileOrFolder) {
+private string getPathForContainer(@container fileOrFolder) {
   files(fileOrFolder, result) or folders(fileOrFolder, result)
 }
 
-/*- Source elements -*/
+/*- Discardable entities and their discard predicates -*/
+/** Python database entities that use named TRAP IDs; the rest use *-ids. */
+overlay[local]
+private class NamedEntity = @py_Module or @container or @py_cobject;
+
+overlay[discard_entity]
+private predicate discardNamedEntity(@top el) {
+  el instanceof NamedEntity and
+  // Entities with named IDs can exist both in base, overlay, or both.
+  exists(Discardable d | d = el |
+    overlayChangedFiles(d.getPath()) and
+    not d.existsInOverlay()
+  )
+}
+
+overlay[discard_entity]
+private predicate discardStarEntity(@top el) {
+  not el instanceof NamedEntity and
+  // Entities with *-ids can exist either in base or overlay, but not both.
+  exists(Discardable d | d = el |
+    overlayChangedFiles(d.getPath()) and
+    d.existsInBase()
+  )
+}
+
 /**
  * An abstract base class for all elements that can be discarded from the base.
  */
 overlay[local]
-abstract private class Discardable extends @py_source_element {
+abstract private class Discardable extends @top {
   /** Gets the path to the file in which this element occurs. */
   abstract string getPath();
 
@@ -51,98 +75,51 @@ abstract private class Discardable extends @py_source_element {
   string toString() { none() }
 }
 
-overlay[discard_entity]
-private predicate discardEntity(@py_source_element el) {
-  exists(Discardable d | d = el |
-    overlayChangedFiles(d.getPath()) and
-    d.existsInBase() and
-    not d.existsInOverlay()
-  )
-}
-
 /**
- * Discard all locatable AST nodes (`@py_location_parent`) in modified files
- * since they use *-ids and hence cannot be referenced across TRAP files.
+ * Discardable locatable AST nodes (`@py_location_parent`).
  */
 overlay[local]
 final private class DiscardableLocatable extends Discardable instanceof @py_location_parent {
   override string getPath() {
-    exists(@location loc | py_locations(loc, this) | result = getRawPathForLocation(loc))
+    exists(@location loc | py_locations(loc, this) | result = getPathForLocation(loc))
   }
 }
 
 /**
- * Discard scopes (classes, functions, modules) that were deleted in the overlay.
+ * Discardable scopes (classes, functions, modules).
  */
 overlay[local]
 final private class DiscardableScope extends Discardable instanceof @py_scope {
   override string getPath() {
-    exists(@location loc | py_scope_location(loc, this) | result = getRawPathForLocation(loc))
+    exists(@location loc | py_scope_location(loc, this) | result = getPathForLocation(loc))
     or
-    result = getRawPathForModule(this)
+    result = getPathForModule(this)
   }
 }
 
 /**
- * Discard files and folders that were deleted in the overlay.
+ * Discardable files and folders.
  */
 overlay[local]
 final private class DiscardableContainer extends Discardable instanceof @container {
-  override string getPath() { result = getRawPathForContainer(this) }
+  override string getPath() { result = getPathForContainer(this) }
 }
 
-/*- CFG Nodes -*/
 /** Discardable control flow nodes */
 overlay[local]
-final private class DiscardableCfgNode instanceof @py_flow_node {
-  string getPath() {
+final private class DiscardableCfgNode extends Discardable instanceof @py_flow_node {
+  override string getPath() {
     exists(Discardable d | result = d.getPath() |
       py_flow_bb_node(this, d.(@py_ast_node), _, _)
       or
       py_scope_flow(this, d.(@py_scope), _)
     )
   }
-
-  predicate existsInBase() { not isOverlay() and exists(this) }
-
-  predicate existsInOverlay() { isOverlay() and exists(this) }
-
-  string toString() { none() }
-}
-
-overlay[discard_entity]
-private predicate discardCfgNode(@py_flow_node n) {
-  exists(DiscardableCfgNode d | d = n |
-    overlayChangedFiles(d.getPath()) and
-    d.existsInBase() and
-    not d.existsInOverlay()
-  )
 }
 
-/*- Variables -*/
-/** Discardable (normal and SSA) variables */
+/** Discardable Python variables. */
 overlay[local]
-abstract private class DiscardableBaseVar instanceof @py_base_var {
-  abstract string getPath();
-
-  predicate existsInBase() { not isOverlay() and exists(this) }
-
-  predicate existsInOverlay() { isOverlay() and exists(this) }
-
-  string toString() { none() }
-}
-
-overlay[discard_entity]
-private predicate discardVar(@py_base_var n) {
-  exists(DiscardableVar d | d = n |
-    overlayChangedFiles(d.getPath()) and
-    d.existsInBase() and
-    not d.existsInOverlay()
-  )
-}
-
-overlay[local]
-final private class DiscardableVar extends DiscardableBaseVar instanceof @py_variable {
+final private class DiscardableVar extends Discardable instanceof @py_variable {
   override string getPath() {
     exists(Discardable parent | result = parent.getPath() |
       variable(this, parent.(@py_scope), _)
@@ -152,8 +129,9 @@ final private class DiscardableVar extends DiscardableBaseVar instanceof @py_var
   }
 }
 
+/** Discardable SSA variables. */
 overlay[local]
-final private class DiscardableSsaVar extends DiscardableBaseVar instanceof @py_ssa_var {
+final private class DiscardableSsaVar extends Discardable instanceof @py_ssa_var {
   override string getPath() {
     exists(DiscardableSsaVar other | result = other.getPath() |
       py_ssa_phi(this, other.(@py_ssa_var))
@@ -169,18 +147,180 @@ final private class DiscardableSsaVar extends DiscardableBaseVar instanceof @py_
   }
 }
 
-/*- Locations -*/
+/** Discardable locations. */
 overlay[local]
-private predicate locationExistsInBase(@location loc) { not isOverlay() and exists(loc) }
+final private class DiscardableLocation extends Discardable instanceof @location {
+  override string getPath() { result = getPathForLocation(this) }
+}
 
+/** Discardable lines. */
 overlay[local]
-private predicate locationExistsInOverlay(@location loc) { isOverlay() and exists(loc) }
+final private class DiscardableLine extends Discardable instanceof @py_line {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_line_lengths(this, d.(@py_Module), _, _))
+  }
+}
 
-overlay[discard_entity]
-private predicate discardLocation(@location loc) {
-  overlayChangedFiles(getRawPathForLocation(loc)) and
-  locationExistsInBase(loc) and
-  not locationExistsInOverlay(loc)
+/** Discardable string part lists. */
+overlay[local]
+final private class DiscardableStringPartList extends Discardable instanceof @py_StringPart_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_StringPart_lists(this, d.(@py_Bytes_or_Str)))
+  }
+}
+
+/** Discardable alias */
+overlay[local]
+final private class DiscardableAlias extends Discardable instanceof @py_alias {
+  override string getPath() {
+    exists(DiscardableAliasList d | result = d.getPath() | py_aliases(this, d, _))
+  }
+}
+
+/** Discardable alias list */
+overlay[local]
+final private class DiscardableAliasList extends Discardable instanceof @py_alias_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_alias_lists(this, d.(@py_Import)))
+  }
+}
+
+/** Discardable arguments */
+overlay[local]
+final private class DiscardableArguments extends Discardable instanceof @py_arguments {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_arguments(this, d.(@py_arguments_parent)))
+  }
+}
+
+/** Discardable boolop */
+overlay[local]
+final private class DiscardableBoolOp extends Discardable instanceof @py_boolop {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_boolops(this, _, d.(@py_BoolExpr)))
+  }
+}
+
+/** Discardable cmpop */
+overlay[local]
+final private class DiscardableCmpOp extends Discardable instanceof @py_cmpop {
+  override string getPath() {
+    exists(DiscardableCmpOpList d | result = d.getPath() | py_cmpops(this, _, d, _))
+  }
+}
+
+/** Discardable cmpop list */
+overlay[local]
+final private class DiscardableCmpOpList extends Discardable instanceof @py_cmpop_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_cmpop_lists(this, d.(@py_Compare)))
+  }
+}
+
+/** Discardable comprehension list */
+overlay[local]
+final private class DiscardableComprehensionList extends Discardable instanceof @py_comprehension_list
+{
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_comprehension_lists(this, d.(@py_ListComp)))
+  }
+}
+
+/** Discardable dict item list */
+overlay[local]
+final private class DiscardableDictItemList extends Discardable instanceof @py_dict_item_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() |
+      py_dict_item_lists(this, d.(@py_dict_item_list_parent))
+    )
+  }
+}
+
+/** Discardable expr context */
+overlay[local]
+final private class DiscardableExprContext extends Discardable instanceof @py_expr_context {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() |
+      py_expr_contexts(this, _, d.(@py_expr_context_parent))
+    )
+  }
+}
+
+/** Discardable expr list */
+overlay[local]
+final private class DiscardableExprList extends Discardable instanceof @py_expr_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_expr_lists(this, d.(@py_expr_list_parent), _))
+  }
+}
+
+/** Discardable operator */
+overlay[local]
+final private class DiscardableOperator extends Discardable instanceof @py_operator {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_operators(this, _, d.(@py_BinaryExpr)))
+  }
+}
+
+/** Discardable parameter list */
+overlay[local]
+final private class DiscardableParameterList extends Discardable instanceof @py_parameter_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_parameter_lists(this, d.(@py_Function)))
+  }
+}
+
+/** Discardable pattern list */
+overlay[local]
+final private class DiscardablePatternList extends Discardable instanceof @py_pattern_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() |
+      py_pattern_lists(this, d.(@py_pattern_list_parent), _)
+    )
+  }
+}
+
+/** Discardable stmt list */
+overlay[local]
+final private class DiscardableStmtList extends Discardable instanceof @py_stmt_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_stmt_lists(this, d.(@py_stmt_list_parent), _))
+  }
+}
+
+/** Discardable str list */
+overlay[local]
+final private class DiscardableStrList extends Discardable instanceof @py_str_list {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_str_lists(this, d.(@py_str_list_parent)))
+  }
+}
+
+/** Discardable type parameter list */
+overlay[local]
+final private class DiscardableTypeParameterList extends Discardable instanceof @py_type_parameter_list
+{
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() |
+      py_type_parameter_lists(this, d.(@py_type_parameter_list_parent))
+    )
+  }
+}
+
+/** Discardable unaryop */
+overlay[local]
+final private class DiscardableUnaryOp extends Discardable instanceof @py_unaryop {
+  override string getPath() {
+    exists(Discardable d | result = d.getPath() | py_unaryops(this, _, d.(@py_UnaryExpr)))
+  }
+}
+
+/** Discardable comment */
+overlay[local]
+final private class DiscardableComment extends Discardable instanceof @py_comment {
+  override string getPath() {
+    exists(DiscardableLocation d | result = d.getPath() | py_comments(this, _, d))
+  }
 }
 
 /*- XML -*/