Swift: make hideability spread upward in the hierarchy

Author: redsun82

misc/codegen/generators/qlgen.py

@@ -166,7 +166,6 @@ def get_ql_class(cls: schema.Class, lookup: typing.Dict[str, schema.Class]) -> q
         ipa=bool(cls.ipa),
         doc=cls.doc,
         hideable=cls.hideable,
-        hideable_root=cls.hideable_root,
         **pragmas,
     )
 

misc/codegen/lib/ql.py

@@ -114,7 +114,6 @@ class Class:
     ql_internal: bool = False
     ipa: bool = False
     doc: List[str] = field(default_factory=list)
-    hideable_root: bool = False
     hideable: bool = False
 
     def __post_init__(self):

misc/codegen/lib/schema.py

@@ -91,7 +91,6 @@ class Class:
     """^^^ filled with `True` for non-final classes with only synthesized final descendants """
     doc: List[str] = field(default_factory=list)
     default_doc_name: Optional[str] = None
-    hideable_root: bool = False
     hideable: bool = False
 
     @property

misc/codegen/loaders/schemaloader.py

@@ -39,7 +39,6 @@ def _get_class(cls: type) -> schema.Class:
                         group=getattr(cls, "_group", ""),
                         hideable=getattr(cls, "_hideable", False),
                         # in the following we don't use `getattr` to avoid inheriting
-                        hideable_root=cls.__dict__.get("_hideable", False),
                         pragmas=cls.__dict__.get("_pragmas", []),
                         ipa=cls.__dict__.get("_ipa", None),
                         properties=[
@@ -96,6 +95,18 @@ def fill_is_ipa(name: str):
             cls.ipa = True
 
 
+def _fill_hideable_information(classes: typing.Dict[str, schema.Class]):
+    """ Update the class map propagating the `hideable` attribute upwards in the hierarchy """
+    todo = [cls for cls in classes.values() if cls.hideable]
+    while todo:
+        cls = todo.pop()
+        for base in cls.bases:
+            supercls = classes[base]
+            if not supercls.hideable:
+                supercls.hideable = True
+                todo.append(supercls)
+
+
 def load(m: types.ModuleType) -> schema.Schema:
     includes = set()
     classes = {}
@@ -124,6 +135,7 @@ def load(m: types.ModuleType) -> schema.Schema:
             cls.is_null_class = True
 
     _fill_ipa_information(classes)
+    _fill_hideable_information(classes)
 
     return schema.Schema(includes=includes, classes=_toposort_classes_by_group(classes), null=null)
 

misc/codegen/templates/ql_class.mustache

@@ -37,8 +37,7 @@ module Generated {
      * Gets a comma-separated list of the names of the primary CodeQL classes to which this element belongs.
      */
     final string getPrimaryQlClasses() { result = concat(this.getAPrimaryQlClass(), ",") }
-    {{/root}}
-    {{#hideable_root}}
+
     /**
      * Gets the most immediate element that should substitute this element in the explicit AST, if any.
      * Classes can override this to indicate this node should be in the "hidden" AST, mostly reserved
@@ -55,7 +54,7 @@ module Generated {
       or
       result = this.getResolveStep().resolve()
     }
-    {{/hideable_root}}
+    {{/root}}
     {{#final}}
     override string getAPrimaryQlClass() { result = "{{name}}" }
     {{/final}}

misc/codegen/templates/ql_parent.mustache

@@ -64,32 +64,28 @@ none()
     {{/final}}
 {{/classes}}
 }
-
-Element resolve(Element e) {
-  {{#classes}}{{#hideable_root}}if e instanceof {{name}} then result = e.({{name}}).resolve() else {{/hideable_root}}{{/classes}}result = e
-}
 }
 
 /**
 * Gets the "immediate" parent of `e`. "Immediate" means not taking into account node resolution: for example
 * if `e` has conversions, `getImmediateParent(e)` will give the innermost conversion in the hidden AST.
 */
 Element getImmediateParent(Element e) {
-// `unique` is used here to tell the optimizer that there is in fact only one result
-// this is tested by the `library-tests/parent/no_double_parents.ql` test
-result = unique(Element x | e = Impl::getImmediateChild(x, _, _) | x)
+    // `unique` is used here to tell the optimizer that there is in fact only one result
+    // this is tested by the `library-tests/parent/no_double_parents.ql` test
+    result = unique(Element x | e = Impl::getImmediateChild(x, _, _) | x)
 }
 
 /**
 * Gets the immediate child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. `accessor` is bound the member predicate call resulting in the given child.
 */
 Element getImmediateChildAndAccessor(Element e, int index, string accessor) {
-exists(string partialAccessor | result = Impl::getImmediateChild(e, index, partialAccessor) and accessor = "get" + partialAccessor)
+    exists(string partialAccessor | result = Impl::getImmediateChild(e, index, partialAccessor) and accessor = "get" + partialAccessor)
 }
 
 /**
 * Gets the child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. `accessor` is bound the member predicate call resulting in the given child.
 */
 Element getChildAndAccessor(Element e, int index, string accessor) {
-exists(string partialAccessor | result = Impl::resolve(Impl::getImmediateChild(e, index, partialAccessor)) and accessor = "get" + partialAccessor)
+    exists(string partialAccessor | result = Impl::getImmediateChild(e, index, partialAccessor).resolve() and accessor = "get" + partialAccessor)
 }

misc/codegen/test/test_qlgen.py

@@ -880,14 +880,6 @@ def test_hideable_class(generate_classes):
     }
 
 
-def test_hideable_root_class(generate_classes):
-    assert generate_classes([
-        schema.Class("MyObject", hideable_root=True),
-    ]) == {
-        "MyObject.qll": (a_ql_stub(name="MyObject"), a_ql_class(name="MyObject", final=True, hideable_root=True)),
-    }
-
-
 def test_hideable_property(generate_classes):
     assert generate_classes([
         schema.Class("MyObject", hideable=True),

misc/codegen/test/test_schemaloader.py

@@ -698,11 +698,22 @@ class Root:
         class A(Root):
             pass
 
-        class B(A):
+        class IndirectlyHideable(Root):
+            pass
+
+        class B(A, IndirectlyHideable):
             pass
 
-    assert data.classes["A"] == schema.Class("A", bases=["Root"], derived={"B"}, hideable_root=True, hideable=True)
-    assert data.classes["B"] == schema.Class("B", bases=["A"], hideable=True)
+        class NonHideable(Root):
+            pass
+
+    assert data.classes == {
+        "Root": schema.Class("Root", derived={"A", "IndirectlyHideable", "NonHideable"}, hideable=True),
+        "A": schema.Class("A", bases=["Root"], derived={"B"}, hideable=True),
+        "IndirectlyHideable": schema.Class("IndirectlyHideable", bases=["Root"], derived={"B"}, hideable=True),
+        "B": schema.Class("B", bases=["A", "IndirectlyHideable"], hideable=True),
+        "NonHideable": schema.Class("NonHideable", bases=["Root"], hideable=False),
+    }
 
 
 if __name__ == '__main__':