Swift: move toposort in schema.py

This makes the result of code generation independent of the order
in which classes are defined in the schema, and makes additional
topological sorting not required.

Being independent from schema order will be important for reviewing the
move to a pure python schema, as generated code will be left untouched.

Author: redsun82

swift/codegen/generators/cppgen.py

@@ -16,7 +16,6 @@
 from typing import Dict
 
 import inflection
-from toposort import toposort_flatten
 
 from swift.codegen.lib import cpp, schema
 
@@ -71,13 +70,9 @@ def _get_class(self, name: str) -> cpp.Class:
         )
 
     def get_classes(self):
-        grouped = {pathlib.Path(): {}}
+        ret = {pathlib.Path(): []}
         for k, cls in self._classmap.items():
-            grouped.setdefault(cls.dir, {}).update({k: cls})
-        ret = {}
-        for dir, map in grouped.items():
-            inheritance_graph = {k: {b for b in cls.bases if b in map} for k, cls in map.items()}
-            ret[dir] = [self._get_class(cls) for cls in toposort_flatten(inheritance_graph)]
+            ret.setdefault(cls.dir, []).append(self._get_class(cls.name))
         return ret
 
 

swift/codegen/generators/qlgen.py

@@ -28,7 +28,6 @@
 import itertools
 
 import inflection
-from toposort import toposort_flatten
 
 from swift.codegen.lib import schema, ql
 
@@ -263,9 +262,7 @@ def generate(opts, renderer):
 
     imports = {}
 
-    inheritance_graph = {name: cls.bases for name, cls in data.classes.items()}
-    toposorted_names = toposort_flatten(inheritance_graph)
-    db_classes = [classes[name] for name in toposorted_names if not classes[name].ipa]
+    db_classes = [cls for cls in classes.values() if not cls.ipa]
     renderer.render(ql.DbClasses(db_classes), out / "Raw.qll")
 
     classes_by_dir_and_name = sorted(classes.values(), key=lambda cls: (cls.dir, cls.name))
@@ -286,8 +283,7 @@ def generate(opts, renderer):
     include_file = stub_out.with_suffix(".qll")
     renderer.render(ql.ImportList(list(imports.values())), include_file)
 
-    toposorted_classes = [classes[name] for name in toposorted_names]
-    renderer.render(ql.GetParentImplementation(toposorted_classes), out / 'ParentChild.qll')
+    renderer.render(ql.GetParentImplementation(list(classes.values())), out / 'ParentChild.qll')
 
     for c in data.classes.values():
         if _should_skip_qltest(c, data.classes):

swift/codegen/lib/schema.py

@@ -4,6 +4,7 @@
 import re
 from dataclasses import dataclass, field
 from typing import List, Set, Union, Dict, ClassVar, Optional
+from toposort import toposort_flatten
 
 import yaml
 
@@ -167,4 +168,17 @@ def load(path):
             cls.bases = [root_class_name]
             classes[root_class_name].derived.add(name)
 
-    return Schema(classes=classes, includes=set(data.get("_includes", [])))
+    groups = {}
+
+    for name, cls in classes.items():
+        groups.setdefault(cls.dir, []).append(name)
+
+    sorted_classes = {}
+
+    for dir in sorted(groups):
+        group = groups[dir]
+        inheritance = {name: classes[name].bases for name in group}
+        for name in toposort_flatten(inheritance):
+            sorted_classes[name] = classes[name]
+
+    return Schema(classes=sorted_classes, includes=set(data.get("_includes", [])))

swift/codegen/test/test_cppgen.py

@@ -56,23 +56,6 @@ def test_two_class_hierarchy(generate):
     ]
 
 
-def test_complex_hierarchy_topologically_ordered(generate):
-    a = cpp.Class(name="A")
-    b = cpp.Class(name="B")
-    c = cpp.Class(name="C", bases=[a])
-    d = cpp.Class(name="D", bases=[a])
-    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="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="A", derived={"C", "D"}),
-    ]) == [a, b, c, d, e, f]
-
-
 @pytest.mark.parametrize("type,expected", [
     ("a", "a"),
     ("string", "std::string"),
@@ -154,8 +137,8 @@ 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="CBase", derived={"C"}, dir=pathlib.Path("bar")),
+        schema.Class(name="C", bases=["CBase"], dir=pathlib.Path("bar")),
         schema.Class(name="D", dir=pathlib.Path("foo/bar/baz")),
     ]) == {
         ".": [cpp.Class(name="A", trap_name="As", final=True)],

swift/codegen/test/test_qlgen.py

@@ -177,10 +177,10 @@ def test_hierarchy_imports(generate_import_list):
 
 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("A", derived={"B", "C"}),
+        schema.Class("B", bases=["A"], derived={"D"}),
+        schema.Class("C", bases=["A"], derived={"D"}),
+        schema.Class("D", bases=["B", "C"]),
     ]) == ql.GetParentImplementation(
         classes=[ql.Class(name="A"),
                  ql.Class(name="B", bases=["A"], imports=[