Merge pull request #10508 from github/redsun82/swift-early-toposort

Swift: move toposort in `schema.py`

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=[