Merge pull request #13249 from github/redsun82/swift-hidden-ast

Swift: make only certain elements hideable in the AST

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,7 @@ 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,
         **pragmas,
     )
 
@@ -254,7 +256,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 +331,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,7 @@ class Class:
     ql_internal: bool = False
     ipa: bool = False
     doc: List[str] = field(default_factory=list)
+    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/lib/schema.py

@@ -91,6 +91,7 @@ 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: bool = False
 
     @property
     def final(self):

misc/codegen/lib/schemadefs.py

@@ -145,6 +145,7 @@ def f(cls: type) -> type:
 _Pragma("qltest_uncollapse_hierarchy")
 
 ql.default_doc_name = lambda doc: _annotate(doc_name=doc)
+ql.hideable = _annotate(hideable=True)
 _Pragma("ql_internal")
 
 _Pragma("cpp_skip")

misc/codegen/loaders/schemaloader.py

@@ -37,6 +37,7 @@ def _get_class(cls: type) -> schema.Class:
                         derived={d.__name__ for d in cls.__subclasses__()},
                         # getattr to inherit from bases
                         group=getattr(cls, "_group", ""),
+                        hideable=getattr(cls, "_hideable", False),
                         # in the following we don't use `getattr` to avoid inheriting
                         pragmas=cls.__dict__.get("_pragmas", []),
                         ipa=cls.__dict__.get("_ipa", None),
@@ -94,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 = {}
@@ -122,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

@@ -60,7 +60,7 @@ module Generated {
     {{/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 +85,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 +100,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}}
@@ -71,21 +71,21 @@ none()
 * 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::getImmediateChild(e, index, partialAccessor).resolve() and accessor = "get" + partialAccessor)
+    exists(string partialAccessor | result = Impl::getImmediateChild(e, index, partialAccessor).resolve() and accessor = "get" + partialAccessor)
 }