Merge pull request #10237 from github/redsun82/swift-generate-printast

Swift: add generic type parameters to AST children

Author: redsun82

swift/codegen/lib/ql.py

@@ -96,8 +96,7 @@ class Class:
     ipa: bool = False
 
     def __post_init__(self):
-        bases = sorted(str(b) for b in self.bases)
-        self.bases = [Base(str(b), prev) for b, prev in zip(bases, itertools.chain([""], bases))]
+        self.bases = [Base(str(b), str(prev)) for b, prev in zip(self.bases, itertools.chain([""], self.bases))]
         if self.properties:
             self.properties[0].first = True
 

swift/codegen/lib/schema.py

@@ -65,7 +65,7 @@ class IpaInfo:
 @dataclass
 class Class:
     name: str
-    bases: Set[str] = field(default_factory=set)
+    bases: List[str] = field(default_factory=set)
     derived: Set[str] = field(default_factory=set)
     properties: List[Property] = field(default_factory=list)
     dir: pathlib.Path = pathlib.Path()
@@ -150,9 +150,8 @@ def load(path):
             if not k.startswith("_"):
                 cls.properties.append(_parse_property(k, v))
             elif k == "_extends":
-                v = _auto_list(v)
-                for base in v:
-                    cls.bases.add(base)
+                cls.bases = _auto_list(v)
+                for base in cls.bases:
                     classes[base].derived.add(name)
             elif k == "_dir":
                 cls.dir = pathlib.Path(v)
@@ -165,7 +164,7 @@ def load(path):
             else:
                 raise Error(f"unknown metadata {k} for class {name}")
         if not cls.bases and cls.name != root_class_name:
-            cls.bases.add(root_class_name)
+            cls.bases = [root_class_name]
             classes[root_class_name].derived.add(name)
 
     return Schema(classes=classes, includes=set(data.get("_includes", [])))

swift/codegen/schema.yml

@@ -72,8 +72,8 @@ ExtensionDecl:
 
 NominalTypeDecl:
   _extends:
-    - IterableDeclContext
     - GenericTypeDecl
+    - IterableDeclContext
   type: Type
 
 AstNode:
@@ -1109,7 +1109,8 @@ AbstractTypeParamDecl:
   _extends: TypeDecl
 
 GenericContext:
-  generic_type_params: GenericTypeParamDecl*
+  _children:
+    generic_type_params: GenericTypeParamDecl*
 
 GenericTypeDecl:
   _extends:

swift/codegen/test/test_cppgen.py

@@ -49,7 +49,7 @@ def test_two_class_hierarchy(generate):
     base = cpp.Class(name="A")
     assert generate([
         schema.Class(name="A", derived={"B"}),
-        schema.Class(name="B", bases={"A"}),
+        schema.Class(name="B", bases=["A"]),
     ]) == [
         base,
         cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
@@ -64,11 +64,11 @@ def test_complex_hierarchy_topologically_ordered(generate):
     e = cpp.Class(name="E", bases=[b, c, d], final=True, trap_name="Es")
     f = cpp.Class(name="F", bases=[c], final=True, trap_name="Fs")
     assert generate([
-        schema.Class(name="F", bases={"C"}),
+        schema.Class(name="F", bases=["C"]),
         schema.Class(name="B", derived={"E"}),
-        schema.Class(name="D", bases={"A"}, derived={"E"}),
-        schema.Class(name="C", bases={"A"}, derived={"E", "F"}),
-        schema.Class(name="E", bases={"B", "C", "D"}),
+        schema.Class(name="D", bases=["A"], derived={"E"}),
+        schema.Class(name="C", bases=["A"], derived={"E", "F"}),
+        schema.Class(name="E", bases=["B", "C", "D"]),
         schema.Class(name="A", derived={"C", "D"}),
     ]) == [a, b, c, d, e, f]
 
@@ -154,7 +154,7 @@ def test_classes_with_dirs(generate_grouped):
     assert generate_grouped([
         schema.Class(name="A"),
         schema.Class(name="B", dir=pathlib.Path("foo")),
-        schema.Class(name="C", bases={"CBase"}, dir=pathlib.Path("bar")),
+        schema.Class(name="C", bases=["CBase"], dir=pathlib.Path("bar")),
         schema.Class(name="CBase", derived={"C"}, dir=pathlib.Path("bar")),
         schema.Class(name="D", dir=pathlib.Path("foo/bar/baz")),
     ]) == {

swift/codegen/test/test_ql.py

@@ -80,7 +80,7 @@ def test_property_predicate_getter():
 
 def test_class_processes_bases():
     bases = ["B", "Ab", "C", "Aa"]
-    expected = [ql.Base("Aa"), ql.Base("Ab", prev="Aa"), ql.Base("B", prev="Ab"), ql.Base("C", prev="B")]
+    expected = [ql.Base("B"), ql.Base("Ab", prev="B"), ql.Base("C", prev="Ab"), ql.Base("Aa", prev="C")]
     cls = ql.Class("Foo", bases=bases)
     assert cls.bases == expected
 

swift/codegen/test/test_qlgen.py

@@ -149,9 +149,9 @@ def test_one_empty_class(generate_classes):
 
 def test_hierarchy(generate_classes):
     assert generate_classes([
-        schema.Class("D", bases={"B", "C"}),
-        schema.Class("C", bases={"A"}, derived={"D"}),
-        schema.Class("B", bases={"A"}, derived={"D"}),
+        schema.Class("D", bases=["B", "C"]),
+        schema.Class("C", bases=["A"], derived={"D"}),
+        schema.Class("B", bases=["A"], derived={"D"}),
         schema.Class("A", derived={"B", "C"}),
     ]) == {
         "A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
@@ -168,18 +168,18 @@ def test_hierarchy(generate_classes):
 
 def test_hierarchy_imports(generate_import_list):
     assert generate_import_list([
-        schema.Class("D", bases={"B", "C"}),
-        schema.Class("C", bases={"A"}, derived={"D"}),
-        schema.Class("B", bases={"A"}, derived={"D"}),
+        schema.Class("D", bases=["B", "C"]),
+        schema.Class("C", bases=["A"], derived={"D"}),
+        schema.Class("B", bases=["A"], derived={"D"}),
         schema.Class("A", derived={"B", "C"}),
     ]) == ql.ImportList([stub_import_prefix + cls for cls in "ABCD"])
 
 
 def test_hierarchy_children(generate_children_implementations):
     assert generate_children_implementations([
-        schema.Class("D", bases={"B", "C"}),
-        schema.Class("C", bases={"A"}, derived={"D"}),
-        schema.Class("B", bases={"A"}, derived={"D"}),
+        schema.Class("D", bases=["B", "C"]),
+        schema.Class("C", bases=["A"], derived={"D"}),
+        schema.Class("B", bases=["A"], derived={"D"}),
         schema.Class("A", derived={"B", "C"}),
     ]) == ql.GetParentImplementation(
         classes=[ql.Class(name="A"),
@@ -347,7 +347,7 @@ def test_class_dir(generate_classes):
     dir = pathlib.Path("another/rel/path")
     assert generate_classes([
         schema.Class("A", derived={"B"}, dir=dir),
-        schema.Class("B", bases={"A"}),
+        schema.Class("B", bases=["A"]),
     ]) == {
         f"{dir}/A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "another.rel.path.A"),
                          ql.Class(name="A", dir=dir)),
@@ -368,7 +368,7 @@ def test_class_dir_imports(generate_import_list):
     dir = pathlib.Path("another/rel/path")
     assert generate_import_list([
         schema.Class("A", derived={"B"}, dir=dir),
-        schema.Class("B", bases={"A"}),
+        schema.Class("B", bases=["A"]),
     ]) == ql.ImportList([
         stub_import_prefix + "B",
         stub_import_prefix + "another.rel.path.A",
@@ -475,7 +475,7 @@ def test_test_total_properties(opts, generate_tests):
         schema.Class("A", derived={"B"}, properties=[
             schema.SingleProperty("x", "string"),
         ]),
-        schema.Class("B", bases={"A"}, properties=[
+        schema.Class("B", bases=["A"], properties=[
             schema.PredicateProperty("y", "int"),
         ]),
     ]) == {
@@ -494,7 +494,7 @@ def test_test_partial_properties(opts, generate_tests):
         schema.Class("A", derived={"B"}, properties=[
             schema.OptionalProperty("x", "string"),
         ]),
-        schema.Class("B", bases={"A"}, properties=[
+        schema.Class("B", bases=["A"], properties=[
             schema.RepeatedProperty("y", "int"),
         ]),
     ]) == {
@@ -514,9 +514,9 @@ def test_test_properties_deduplicated(opts, generate_tests):
             schema.SingleProperty("x", "string"),
             schema.RepeatedProperty("y", "int"),
         ]),
-        schema.Class("A", bases={"Base"}, derived={"Final"}),
-        schema.Class("B", bases={"Base"}, derived={"Final"}),
-        schema.Class("Final", bases={"A", "B"}),
+        schema.Class("A", bases=["Base"], derived={"Final"}),
+        schema.Class("B", bases=["Base"], derived={"Final"}),
+        schema.Class("Final", bases=["A", "B"]),
     ]) == {
         "Final/Final.ql": ql.ClassTester(class_name="Final", properties=[
             ql.PropertyForTest(
@@ -535,7 +535,7 @@ def test_test_properties_skipped(opts, generate_tests):
             schema.SingleProperty("x", "string", pragmas=["qltest_skip", "foo"]),
             schema.RepeatedProperty("y", "int", pragmas=["bar", "qltest_skip"]),
         ]),
-        schema.Class("Derived", bases={"Base"}, properties=[
+        schema.Class("Derived", bases=["Base"], properties=[
             schema.PredicateProperty("a", pragmas=["qltest_skip"]),
             schema.OptionalProperty(
                 "b", "int", pragmas=["bar", "qltest_skip", "baz"]),
@@ -552,7 +552,7 @@ def test_test_base_class_skipped(opts, generate_tests):
             schema.SingleProperty("x", "string"),
             schema.RepeatedProperty("y", "int"),
         ]),
-        schema.Class("Derived", bases={"Base"}),
+        schema.Class("Derived", bases=["Base"]),
     ]) == {
         "Derived/Derived.ql": ql.ClassTester(class_name="Derived"),
     }
@@ -562,7 +562,7 @@ def test_test_final_class_skipped(opts, generate_tests):
     write(opts.ql_test_output / "Derived" / "test.swift")
     assert generate_tests([
         schema.Class("Base", derived={"Derived"}),
-        schema.Class("Derived", bases={"Base"}, pragmas=["qltest_skip", "foo"], properties=[
+        schema.Class("Derived", bases=["Base"], pragmas=["qltest_skip", "foo"], properties=[
             schema.SingleProperty("x", "string"),
             schema.RepeatedProperty("y", "int"),
         ]),
@@ -573,9 +573,9 @@ def test_test_class_hierarchy_collapse(opts, generate_tests):
     write(opts.ql_test_output / "Base" / "test.swift")
     assert generate_tests([
         schema.Class("Base", derived={"D1", "D2"}, pragmas=["foo", "qltest_collapse_hierarchy"]),
-        schema.Class("D1", bases={"Base"}, properties=[schema.SingleProperty("x", "string")]),
-        schema.Class("D2", bases={"Base"}, derived={"D3"}, properties=[schema.SingleProperty("y", "string")]),
-        schema.Class("D3", bases={"D2"}, properties=[schema.SingleProperty("z", "string")]),
+        schema.Class("D1", bases=["Base"], properties=[schema.SingleProperty("x", "string")]),
+        schema.Class("D2", bases=["Base"], derived={"D3"}, properties=[schema.SingleProperty("y", "string")]),
+        schema.Class("D3", bases=["D2"], properties=[schema.SingleProperty("z", "string")]),
     ]) == {
         "Base/Base.ql": ql.ClassTester(class_name="Base"),
     }
@@ -586,10 +586,10 @@ def test_test_class_hierarchy_uncollapse(opts, generate_tests):
         write(opts.ql_test_output / d / "test.swift")
     assert generate_tests([
         schema.Class("Base", derived={"D1", "D2"}, pragmas=["foo", "qltest_collapse_hierarchy"]),
-        schema.Class("D1", bases={"Base"}, properties=[schema.SingleProperty("x", "string")]),
-        schema.Class("D2", bases={"Base"}, derived={"D3", "D4"}, pragmas=["qltest_uncollapse_hierarchy", "bar"]),
-        schema.Class("D3", bases={"D2"}),
-        schema.Class("D4", bases={"D2"}),
+        schema.Class("D1", bases=["Base"], properties=[schema.SingleProperty("x", "string")]),
+        schema.Class("D2", bases=["Base"], derived={"D3", "D4"}, pragmas=["qltest_uncollapse_hierarchy", "bar"]),
+        schema.Class("D3", bases=["D2"]),
+        schema.Class("D4", bases=["D2"]),
     ]) == {
         "Base/Base.ql": ql.ClassTester(class_name="Base"),
         "D3/D3.ql": ql.ClassTester(class_name="D3"),
@@ -602,9 +602,9 @@ def test_test_class_hierarchy_uncollapse_at_final(opts, generate_tests):
         write(opts.ql_test_output / d / "test.swift")
     assert generate_tests([
         schema.Class("Base", derived={"D1", "D2"}, pragmas=["foo", "qltest_collapse_hierarchy"]),
-        schema.Class("D1", bases={"Base"}, properties=[schema.SingleProperty("x", "string")]),
-        schema.Class("D2", bases={"Base"}, derived={"D3"}),
-        schema.Class("D3", bases={"D2"}, pragmas=["qltest_uncollapse_hierarchy", "bar"]),
+        schema.Class("D1", bases=["Base"], properties=[schema.SingleProperty("x", "string")]),
+        schema.Class("D2", bases=["Base"], derived={"D3"}),
+        schema.Class("D3", bases=["D2"], pragmas=["qltest_uncollapse_hierarchy", "bar"]),
     ]) == {
         "Base/Base.ql": ql.ClassTester(class_name="Base"),
         "D3/D3.ql": ql.ClassTester(class_name="D3"),