Swift: use IPA layer in generated classes

swift/codegen/test/test_cppgen.py

@@ -12,7 +12,7 @@ def generate_grouped(opts, renderer, input):
     opts.cpp_output = output_dir
 
     def ret(classes):
-        input.classes = classes
+        input.classes = {cls.name: cls for cls in classes}
         generated = run_generation(cppgen.generate, opts, renderer)
         for f, g in generated.items():
             assert isinstance(g, cpp.ClassList), f

swift/codegen/test/test_dbschemegen.py

@@ -8,7 +8,6 @@ from swift.codegen.generators import dbschemegen
 from swift.codegen.lib import dbscheme
 from swift.codegen.test.utils import *
 
-
 InputExpectedPair = collections.namedtuple("InputExpectedPair", ("input", "expected"))
 
 
@@ -20,27 +19,32 @@ def dir_param(request):
     return request.param
 
 
-def generate(opts, renderer):
-    (out, data), = run_generation(dbschemegen.generate, opts, renderer).items()
-    assert out is opts.dbscheme
-    return data
+@pytest.fixture
+def generate(opts, input, renderer):
+    def func(classes):
+        input.classes = {cls.name: cls for cls in classes}
+        (out, data), = run_generation(dbschemegen.generate, opts, renderer).items()
+        assert out is opts.dbscheme
+        return data
+
+    return func
 
 
-def test_empty(opts, input, renderer):
-    assert generate(opts, renderer) == dbscheme.Scheme(
+def test_empty(generate):
+    assert generate([]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[],
     )
 
 
-def test_includes(opts, input, renderer):
+def test_includes(input, opts, generate):
     includes = ["foo", "bar"]
     input.includes = includes
     for i in includes:
         write(opts.schema.parent / i, i + " data")
 
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    assert generate([]) == dbscheme.Scheme(
         src=schema_file,
         includes=[
             dbscheme.SchemeInclude(
@@ -52,11 +56,10 @@ def test_includes(opts, input, renderer):
     )
 
 
-def test_empty_final_class(opts, input, renderer, dir_param):
-    input.classes = [
+def test_empty_final_class(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -71,14 +74,12 @@ def test_empty_final_class(opts, input, renderer, dir_param):
     )
 
 
-def test_final_class_with_single_scalar_field(opts, input, renderer, dir_param):
-    input.classes = [
-
+def test_final_class_with_single_scalar_field(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             schema.SingleProperty("foo", "bar"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -93,13 +94,12 @@ def test_final_class_with_single_scalar_field(opts, input, renderer, dir_param):
     )
 
 
-def test_final_class_with_single_class_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_single_class_field(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             schema.SingleProperty("foo", "Bar"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -114,13 +114,12 @@ def test_final_class_with_single_class_field(opts, input, renderer, dir_param):
     )
 
 
-def test_final_class_with_optional_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_optional_field(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             schema.OptionalProperty("foo", "bar"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -143,13 +142,12 @@ def test_final_class_with_optional_field(opts, input, renderer, dir_param):
 
 
 @pytest.mark.parametrize("property_cls", [schema.RepeatedProperty, schema.RepeatedOptionalProperty])
-def test_final_class_with_repeated_field(opts, input, renderer, property_cls, dir_param):
-    input.classes = [
+def test_final_class_with_repeated_field(generate, property_cls, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             property_cls("foo", "bar"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -172,13 +170,12 @@ def test_final_class_with_repeated_field(opts, input, renderer, property_cls, di
     )
 
 
-def test_final_class_with_predicate_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_predicate_field(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             schema.PredicateProperty("foo"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -199,8 +196,8 @@ def test_final_class_with_predicate_field(opts, input, renderer, dir_param):
     )
 
 
-def test_final_class_with_more_fields(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_more_fields(generate, dir_param):
+    assert generate([
         schema.Class("Object", dir=dir_param.input, properties=[
             schema.SingleProperty("one", "x"),
             schema.SingleProperty("two", "y"),
@@ -209,8 +206,7 @@ def test_final_class_with_more_fields(opts, input, renderer, dir_param):
             schema.RepeatedOptionalProperty("five", "v"),
             schema.PredicateProperty("six"),
         ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -259,12 +255,11 @@ def test_final_class_with_more_fields(opts, input, renderer, dir_param):
     )
 
 
-def test_empty_class_with_derived(opts, input, renderer):
-    input.classes = [
+def test_empty_class_with_derived(generate):
+    assert generate([
         schema.Class(
             name="Base", derived={"Left", "Right"}),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -276,8 +271,8 @@ def test_empty_class_with_derived(opts, input, renderer):
     )
 
 
-def test_class_with_derived_and_single_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_single_property(generate, dir_param):
+    assert generate([
         schema.Class(
             name="Base",
             derived={"Left", "Right"},
@@ -285,8 +280,7 @@ def test_class_with_derived_and_single_property(opts, input, renderer, dir_param
             properties=[
                 schema.SingleProperty("single", "Prop"),
             ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -307,8 +301,8 @@ def test_class_with_derived_and_single_property(opts, input, renderer, dir_param
     )
 
 
-def test_class_with_derived_and_optional_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_optional_property(generate, dir_param):
+    assert generate([
         schema.Class(
             name="Base",
             derived={"Left", "Right"},
@@ -316,8 +310,7 @@ def test_class_with_derived_and_optional_property(opts, input, renderer, dir_par
             properties=[
                 schema.OptionalProperty("opt", "Prop"),
             ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[
@@ -338,8 +331,8 @@ def test_class_with_derived_and_optional_property(opts, input, renderer, dir_par
     )
 
 
-def test_class_with_derived_and_repeated_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_repeated_property(generate, dir_param):
+    assert generate([
         schema.Class(
             name="Base",
             dir=dir_param.input,
@@ -347,8 +340,7 @@ def test_class_with_derived_and_repeated_property(opts, input, renderer, dir_par
             properties=[
                 schema.RepeatedProperty("rep", "Prop"),
             ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
         src=schema_file,
         includes=[],
         declarations=[

swift/codegen/test/test_ql.py

@@ -94,11 +94,6 @@ def test_class_has_first_property_marked():
     assert cls.properties == expected
 
 
-def test_class_db_id():
-    cls = ql.Class("ThisIsMyClass")
-    assert cls.db_id == "@this_is_my_class"
-
-
 def test_root_class():
     cls = ql.Class("Class")
     assert cls.root

swift/codegen/test/test_qlgen.py

@@ -52,7 +52,7 @@ def generate(input, qlgen_opts, renderer):
     renderer.written = []
 
     def func(classes):
-        input.classes = classes
+        input.classes = {cls.name: cls for cls in classes}
         return run_generation(qlgen.generate, qlgen_opts, renderer)
 
     return func
@@ -139,7 +139,7 @@ def test_one_empty_class(generate_classes):
         schema.Class("A")
     ]) == {
         "A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
-                  ql.Class(name="A", final=True)),
+                  ql.Class(name="A", final=True, fields=[ql.Field('id', type='@a')])),
     }
 
 
@@ -157,7 +157,7 @@ def test_hierarchy(generate_classes):
         "C.qll": (ql.Stub(name="C", base_import=gen_import_prefix + "C"),
                   ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"])),
         "D.qll": (ql.Stub(name="D", base_import=gen_import_prefix + "D"),
-                  ql.Class(name="D", final=True, bases=["B", "C"],
+                  ql.Class(name="D", final=True, bases=["B", "C"], fields=[ql.Field("id", type="@d")],
                            imports=[stub_import_prefix + cls for cls in "BC"])),
     }
 
@@ -183,7 +183,7 @@ def test_hierarchy_children(generate_children_implementations):
                      stub_import_prefix + "A"]),
                  ql.Class(name="C", bases=["A"], imports=[
                      stub_import_prefix + "A"]),
-                 ql.Class(name="D", final=True, bases=["B", "C"],
+                 ql.Class(name="D", final=True, bases=["B", "C"], fields=[ql.Field("id", type="@d")],
                           imports=[stub_import_prefix + cls for cls in "BC"]),
                  ],
     )
@@ -195,9 +195,10 @@ def test_single_property(generate_classes):
             schema.SingleProperty("foo", "bar")]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")],
+                                  properties=[
                              ql.Property(singular="Foo", type="bar", tablename="my_objects",
-                                         tableparams=["this", "result"]),
+                                         tableparams=["id", "result"]),
                          ])),
     }
 
@@ -211,13 +212,14 @@ def test_single_properties(generate_classes):
         ]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")],
+                                  properties=[
                              ql.Property(singular="One", type="x", tablename="my_objects",
-                                         tableparams=["this", "result", "_", "_"]),
+                                         tableparams=["id", "result", "_", "_"]),
                              ql.Property(singular="Two", type="y", tablename="my_objects",
-                                         tableparams=["this", "_", "result", "_"]),
+                                         tableparams=["id", "_", "result", "_"]),
                              ql.Property(singular="Three", type="z", tablename="my_objects",
-                                         tableparams=["this", "_", "_", "result"]),
+                                         tableparams=["id", "_", "_", "result"]),
                          ])),
     }
 
@@ -229,9 +231,9 @@ def test_optional_property(generate_classes, is_child):
             schema.OptionalProperty("foo", "bar", is_child=is_child)]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                              ql.Property(singular="Foo", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "result"],
+                                         tableparams=["id", "result"],
                                          is_optional=True, is_child=is_child),
                          ])),
     }
@@ -244,9 +246,9 @@ def test_repeated_property(generate_classes, is_child):
             schema.RepeatedProperty("foo", "bar", is_child=is_child)]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                              ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "index", "result"], is_child=is_child),
+                                         tableparams=["id", "index", "result"], is_child=is_child),
                          ])),
     }
 
@@ -258,9 +260,9 @@ def test_repeated_optional_property(generate_classes, is_child):
             schema.RepeatedOptionalProperty("foo", "bar", is_child=is_child)]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                              ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "index", "result"], is_optional=True,
+                                         tableparams=["id", "index", "result"], is_optional=True,
                                          is_child=is_child),
                          ])),
     }
@@ -272,9 +274,9 @@ def test_predicate_property(generate_classes):
             schema.PredicateProperty("is_foo")]),
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                              ql.Property(singular="isFoo", type="predicate", tablename="my_object_is_foo",
-                                         tableparams=["this"],
+                                         tableparams=["id"],
                                          is_predicate=True),
                          ])),
     }
@@ -289,15 +291,15 @@ def test_single_class_property(generate_classes, is_child):
     ]) == {
         "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
                          ql.Class(
-            name="MyObject", final=True, imports=[stub_import_prefix + "Bar"], properties=[
+            name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], imports=[stub_import_prefix + "Bar"], properties=[
                 ql.Property(singular="Foo", type="Bar", tablename="my_objects",
                             tableparams=[
-                                "this", "result"],
+                                "id", "result"],
                             is_child=is_child),
             ],
         )),
         "Bar.qll": (ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"),
-                    ql.Class(name="Bar", final=True)),
+                    ql.Class(name="Bar", final=True, fields=[ql.Field("id", type="@bar")])),
     }
 
 
@@ -310,7 +312,7 @@ def test_class_dir(generate_classes):
         f"{dir}/A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "another.rel.path.A"),
                          ql.Class(name="A", dir=dir)),
         "B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"),
-                  ql.Class(name="B", final=True, bases=["A"],
+                  ql.Class(name="B", final=True, fields=[ql.Field("id", type="@b")], bases=["A"],
                            imports=[stub_import_prefix + "another.rel.path.A"])),
     }
 

swift/codegen/test/test_schema.py

@@ -20,7 +20,7 @@ def load(tmp_path):
 
 def test_empty_schema(load):
     ret = load("{}")
-    assert ret.classes == [schema.Class(root_name)]
+    assert ret.classes == {root_name: schema.Class(root_name)}
     assert ret.includes == set()
 
 
@@ -28,10 +28,10 @@ def test_one_empty_class(load):
     ret = load("""
 MyClass: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}),
+    }
 
 
 def test_two_empty_classes(load):
@@ -39,11 +39,11 @@ def test_two_empty_classes(load):
 MyClass1: {}
 MyClass2: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass1', 'MyClass2'}),
-        schema.Class('MyClass1', bases={root_name}),
-        schema.Class('MyClass2', bases={root_name}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass1', 'MyClass2'}),
+        'MyClass1': schema.Class('MyClass1', bases={root_name}),
+        'MyClass2': schema.Class('MyClass2', bases={root_name}),
+    }
 
 
 def test_two_empty_chained_classes(load):
@@ -52,11 +52,11 @@ MyClass1: {}
 MyClass2:
     _extends: MyClass1
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass1'}),
-        schema.Class('MyClass1', bases={root_name}, derived={'MyClass2'}),
-        schema.Class('MyClass2', bases={'MyClass1'}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass1'}),
+        'MyClass1': schema.Class('MyClass1', bases={root_name}, derived={'MyClass2'}),
+        'MyClass2': schema.Class('MyClass2', bases={'MyClass1'}),
+    }
 
 
 def test_empty_classes_diamond(load):
@@ -68,12 +68,12 @@ C:
         - A
         - B
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A', 'B'}),
-        schema.Class('A', bases={root_name}, derived={'C'}),
-        schema.Class('B', bases={root_name}, derived={'C'}),
-        schema.Class('C', bases={'A', 'B'}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A', 'B'}),
+        'A': schema.Class('A', bases={root_name}, derived={'C'}),
+        'B': schema.Class('B', bases={root_name}, derived={'C'}),
+        'C': schema.Class('C', bases={'A', 'B'}),
+    }
 
 
 def test_dir(load):
@@ -81,10 +81,10 @@ def test_dir(load):
 A:
     _dir: other/dir
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
+    }
 
 
 def test_directory_filter(load):
@@ -101,16 +101,16 @@ Ax: {}
 Ay: {}
 A: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'Afoo', 'Bbar', 'Abar', 'Bfoo', 'Ax', 'Ay', 'A'}),
-        schema.Class('Afoo', bases={root_name}, dir=pathlib.Path("second/dir")),
-        schema.Class('Bbar', bases={root_name}, dir=pathlib.Path("third/dir")),
-        schema.Class('Abar', bases={root_name}, dir=pathlib.Path("third/dir")),
-        schema.Class('Bfoo', bases={root_name}, dir=pathlib.Path("second/dir")),
-        schema.Class('Ax', bases={root_name}, dir=pathlib.Path("first/dir")),
-        schema.Class('Ay', bases={root_name}, dir=pathlib.Path("first/dir")),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path()),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'Afoo', 'Bbar', 'Abar', 'Bfoo', 'Ax', 'Ay', 'A'}),
+        'Afoo': schema.Class('Afoo', bases={root_name}, dir=pathlib.Path("second/dir")),
+        'Bbar': schema.Class('Bbar', bases={root_name}, dir=pathlib.Path("third/dir")),
+        'Abar': schema.Class('Abar', bases={root_name}, dir=pathlib.Path("third/dir")),
+        'Bfoo': schema.Class('Bfoo', bases={root_name}, dir=pathlib.Path("second/dir")),
+        'Ax': schema.Class('Ax', bases={root_name}, dir=pathlib.Path("first/dir")),
+        'Ay': schema.Class('Ay', bases={root_name}, dir=pathlib.Path("first/dir")),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path()),
+    }
 
 
 def test_directory_filter_override(load):
@@ -120,10 +120,10 @@ _directories:
 A:
     _dir: other/dir
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
+    }
 
 
 def test_lowercase_rejected(load):
@@ -145,16 +145,16 @@ A:
      four: x?*
      five: predicate
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.SingleProperty('one', 'string'),
             schema.OptionalProperty('two', 'int'),
             schema.RepeatedProperty('three', 'bool'),
             schema.RepeatedOptionalProperty('four', 'x'),
             schema.PredicateProperty('five'),
         ]),
-    ]
+    }
 
 
 def test_element_properties(load):
@@ -162,11 +162,11 @@ def test_element_properties(load):
 Element:
     x: string
 """)
-    assert ret.classes == [
-        schema.Class(root_name, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, properties=[
             schema.SingleProperty('x', 'string'),
         ]),
-    ]
+    }
 
 
 def test_children(load):
@@ -180,9 +180,9 @@ A:
         e: E?
         f: F?*
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.SingleProperty('a', 'string'),
             schema.RepeatedProperty('b', 'B'),
             schema.SingleProperty('c', 'C', is_child=True),
@@ -190,7 +190,7 @@ A:
             schema.OptionalProperty('e', 'E', is_child=True),
             schema.RepeatedOptionalProperty('f', 'F', is_child=True),
         ]),
-    ]
+    }
 
 
 @pytest.mark.parametrize("type", ["string", "int", "boolean", "predicate"])
@@ -209,12 +209,12 @@ A:
     x: 
       type: string*
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.RepeatedProperty('x', 'string'),
         ]),
-    ]
+    }
 
 
 def test_property_with_explicit_type_and_pragmas(load):
@@ -224,12 +224,12 @@ A:
       type: string*
       _pragma: [foo, bar]
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.RepeatedProperty('x', 'string', pragmas=["foo", "bar"]),
         ]),
-    ]
+    }
 
 
 def test_property_with_explicit_type_and_one_pragma(load):
@@ -239,12 +239,12 @@ A:
       type: string*
       _pragma: foo
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.RepeatedProperty('x', 'string', pragmas=["foo"]),
         ]),
-    ]
+    }
 
 
 def test_property_with_explicit_type_and_unknown_metadata(load):
@@ -272,12 +272,12 @@ A:
     x: string*
     _pragma: [foo, bar]
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.RepeatedProperty('x', 'string'),
         ], pragmas=["foo", "bar"]),
-    ]
+    }
 
 
 def test_class_with_one_pragma(load):
@@ -286,12 +286,12 @@ A:
     x: string*
     _pragma: foo
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
             schema.RepeatedProperty('x', 'string'),
         ], pragmas=["foo"]),
-    ]
+    }
 
 
 def test_class_with_unknown_metadata(load):
@@ -309,10 +309,10 @@ MyClass:
     _ipa:
         from: A
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(from_class="A")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(from_class="A")),
+    }
 
 
 def test_ipa_class_on(load):
@@ -323,10 +323,10 @@ MyClass:
             x: A
             y: int
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(on_arguments={"x": "A", "y": "int"})),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(on_arguments={"x": "A", "y": "int"})),
+    }
 
 
 # TODO rejection tests and implementation for malformed `_ipa` clauses