Swift: implement @ql.hideable

Author: redsun82

misc/codegen/generators/qlgen.py

@@ -102,15 +102,16 @@ def _get_doc(cls: schema.Class, prop: schema.Property, plural=None):
     return f"{prop_name} of this {class_name}"
 
 
-def get_ql_property(cls: schema.Class, prop: schema.Property, prev_child: str = "") -> ql.Property:
+def get_ql_property(cls: schema.Class, prop: schema.Property, lookup: typing.Dict[str, schema.Class], prev_child: str = "") -> ql.Property:
     args = dict(
         type=prop.type if not prop.is_predicate else "predicate",
         qltest_skip="qltest_skip" in prop.pragmas,
         prev_child=prev_child if prop.is_child else None,
         is_optional=prop.is_optional,
         is_predicate=prop.is_predicate,
         is_unordered=prop.is_unordered,
-        description=prop.description
+        description=prop.description,
+        type_is_hideable=lookup[prop.type].hideable if prop.type in lookup else False,
     )
     if prop.is_single:
         args.update(
@@ -147,12 +148,12 @@ def get_ql_property(cls: schema.Class, prop: schema.Property, prev_child: str =
     return ql.Property(**args)
 
 
-def get_ql_class(cls: schema.Class) -> ql.Class:
+def get_ql_class(cls: schema.Class, lookup: typing.Dict[str, schema.Class]) -> ql.Class:
     pragmas = {k: True for k in cls.pragmas if k.startswith("ql")}
     prev_child = ""
     properties = []
     for p in cls.properties:
-        prop = get_ql_property(cls, p, prev_child)
+        prop = get_ql_property(cls, p, lookup, prev_child)
         if prop.is_child:
             prev_child = prop.singular
         properties.append(prop)
@@ -164,6 +165,8 @@ def get_ql_class(cls: schema.Class) -> ql.Class:
         dir=pathlib.Path(cls.group or ""),
         ipa=bool(cls.ipa),
         doc=cls.doc,
+        hideable=cls.hideable,
+        hideable_root=cls.hideable_root,
         **pragmas,
     )
 
@@ -254,7 +257,7 @@ def _get_all_properties_to_be_tested(cls: schema.Class, lookup: typing.Dict[str,
     for c, p in _get_all_properties(cls, lookup):
         if not ("qltest_skip" in c.pragmas or "qltest_skip" in p.pragmas):
             # TODO here operations are duplicated, but should be better if we split ql and qltest generation
-            p = get_ql_property(c, p)
+            p = get_ql_property(c, p, lookup)
             yield ql.PropertyForTest(p.getter, is_total=p.is_single or p.is_predicate,
                                      type=p.type if not p.is_predicate else None, is_indexed=p.is_indexed)
             if p.is_repeated and not p.is_optional:
@@ -329,7 +332,7 @@ def generate(opts, renderer):
 
     data = schemaloader.load_file(input)
 
-    classes = {name: get_ql_class(cls) for name, cls in data.classes.items()}
+    classes = {name: get_ql_class(cls, data.classes) for name, cls in data.classes.items()}
     if not classes:
         raise NoClasses
     root = next(iter(classes.values()))

misc/codegen/lib/ql.py

@@ -42,6 +42,7 @@ class Property:
     description: List[str] = field(default_factory=list)
     doc: Optional[str] = None
     doc_plural: Optional[str] = None
+    type_is_hideable: bool = False
 
     def __post_init__(self):
         if self.tableparams:
@@ -113,6 +114,8 @@ 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):
         self.bases = [Base(str(b), str(prev)) for b, prev in zip(self.bases, itertools.chain([""], self.bases))]

misc/codegen/templates/ql_class.mustache

@@ -37,7 +37,8 @@ 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
@@ -54,13 +55,13 @@ module Generated {
       or
       result = this.getResolveStep().resolve()
     }
-    {{/root}}
+    {{/hideable_root}}
     {{#final}}
     override string getAPrimaryQlClass() { result = "{{name}}" }
     {{/final}}
     {{#properties}}
 
-    {{#type_is_class}}
+    {{#type_is_hideable}}
     /**
      * {{>ql_property_doc}}     *
      * This includes nodes from the "hidden" AST. It can be overridden in subclasses to change the
@@ -85,11 +86,11 @@ module Generated {
      */
     final {{type}} {{getter}}({{#is_indexed}}int index{{/is_indexed}}) {
       exists({{type}} immediate | immediate = this.get{{#is_unordered}}An{{/is_unordered}}Immediate{{singular}}({{#is_indexed}}index{{/is_indexed}}) and
-        if exists(this.getResolveStep()) then result = immediate else result = immediate.resolve())
+        {{#hideable}}if exists(this.getResolveStep()) then result = immediate else {{/hideable}}result = immediate.resolve())
     }
 
-    {{/type_is_class}}
-    {{^type_is_class}}
+    {{/type_is_hideable}}
+    {{^type_is_hideable}}
     /**
      * {{>ql_property_doc}}     *
     {{#has_description}}
@@ -100,14 +101,14 @@ module Generated {
      */
     {{type}} {{getter}}({{#is_indexed}}int index{{/is_indexed}}) {
       {{^ipa}}
-      {{^is_predicate}}result = {{/is_predicate}}Synth::convert{{name}}ToRaw(this){{^root}}.(Raw::{{name}}){{/root}}.{{getter}}({{#is_indexed}}index{{/is_indexed}})
+      {{^is_predicate}}result = {{/is_predicate}}{{#type_is_class}}Synth::convert{{type}}FromRaw({{/type_is_class}}Synth::convert{{name}}ToRaw(this){{^root}}.(Raw::{{name}}){{/root}}.{{getter}}({{#is_indexed}}index{{/is_indexed}}){{#type_is_class}}){{/type_is_class}}
       {{/ipa}}
       {{#ipa}}
       none()
       {{/ipa}}
     }
 
-    {{/type_is_class}}
+    {{/type_is_hideable}}
     {{#is_optional}}
     /**
      * Holds if `{{getter}}({{#is_repeated}}index{{/is_repeated}})` exists.

misc/codegen/templates/ql_parent.mustache

@@ -28,7 +28,7 @@ private module Impl {
             {{! for single and optional properties it adds 1 (regardless of whether the optional property exists) }}
             {{! for repeated it adds 1 + the maximum index (which works for repeated optional as well) }}
                 and
-                n{{singular}} = n{{prev_child}} + 1{{#is_repeated}}+ max(int i | i = -1 or exists(e.getImmediate{{singular}}(i)) | i){{/is_repeated}}
+                n{{singular}} = n{{prev_child}} + 1{{#is_repeated}}+ max(int i | i = -1 or exists(e.get{{#type_is_hideable}}Immediate{{/type_is_hideable}}{{singular}}(i)) | i){{/is_repeated}}
             {{/is_child}}
         {{/properties}} and (
         none()
@@ -40,10 +40,10 @@ private module Impl {
             {{#is_child}}
                 or
                 {{#is_repeated}}
-                    result = e.getImmediate{{singular}}(index - n{{prev_child}}) and partialPredicateCall = "{{singular}}(" + (index - n{{prev_child}}).toString() + ")"
+                    result = e.get{{#type_is_hideable}}Immediate{{/type_is_hideable}}{{singular}}(index - n{{prev_child}}) and partialPredicateCall = "{{singular}}(" + (index - n{{prev_child}}).toString() + ")"
                 {{/is_repeated}}
                 {{^is_repeated}}
-                    index = n{{prev_child}} and result = e.getImmediate{{singular}}() and partialPredicateCall = "{{singular}}()"
+                    index = n{{prev_child}} and result = e.get{{#type_is_hideable}}Immediate{{/type_is_hideable}}{{singular}}() and partialPredicateCall = "{{singular}}()"
                 {{/is_repeated}}
             {{/is_child}}
         {{/properties}}
@@ -64,6 +64,10 @@ 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
+}
 }
 
 /**
@@ -87,5 +91,5 @@ exists(string partialAccessor | result = Impl::getImmediateChild(e, index, parti
 * 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::getImmediateChild(e, index, partialAccessor).resolve() and accessor = "get" + partialAccessor)
+exists(string partialAccessor | result = Impl::resolve(Impl::getImmediateChild(e, index, partialAccessor)) and accessor = "get" + partialAccessor)
 }