Codegen: add @qltest.test_with

This allows to group together related AST classes to reuse the same
test source and extraction. For example this is useful for
`EnumDecl/EnumCaseDecl/EnumElementDecl`, where this is applied to.

Author: redsun82

misc/codegen/generators/qlgen.py

@@ -381,7 +381,8 @@ def generate(opts, renderer):
             for c in data.classes.values():
                 if _should_skip_qltest(c, data.classes):
                     continue
-                test_dir = test_out / c.group / c.name
+                test_with = data.classes[c.test_with] if c.test_with else c
+                test_dir = test_out / test_with.group / test_with.name
                 test_dir.mkdir(parents=True, exist_ok=True)
                 if all(f.suffix in (".txt", ".ql", ".actual", ".expected") for f in test_dir.glob("*.*")):
                     log.warning(f"no test source in {test_dir.relative_to(test_out)}")

misc/codegen/lib/schema.py

@@ -93,6 +93,7 @@ class Class:
     doc: List[str] = field(default_factory=list)
     default_doc_name: Optional[str] = None
     hideable: bool = False
+    test_with: Optional[str] = None
 
     @property
     def final(self):
@@ -110,6 +111,7 @@ def check_types(self, known: typing.Iterable[str]):
             if self.synth.on_arguments is not None:
                 for t in self.synth.on_arguments.values():
                     _check_type(t, known)
+        _check_type(self.test_with, known)
 
 
 @dataclass

misc/codegen/lib/schemadefs.py

@@ -148,6 +148,7 @@ def f(cls: type) -> type:
 _Pragma("qltest_skip")
 _Pragma("qltest_collapse_hierarchy")
 _Pragma("qltest_uncollapse_hierarchy")
+qltest.test_with = lambda cls: _annotate(test_with=cls)
 
 ql.default_doc_name = lambda doc: _annotate(doc_name=doc)
 ql.hideable = _annotate(hideable=True)

misc/codegen/loaders/schemaloader.py

@@ -19,6 +19,14 @@ def modify(self, prop: schema.Property):
         prop.name = self.name.rstrip("_")
 
 
+def _get_name(x: str | type | None):
+    if x is None:
+        return None
+    if isinstance(x, str):
+        return x
+    return x.__name__
+
+
 def _get_class(cls: type) -> schema.Class:
     if not isinstance(cls, type):
         raise schema.Error(f"Only class definitions allowed in schema, found {cls}")
@@ -38,6 +46,7 @@ def _get_class(cls: type) -> schema.Class:
                         # getattr to inherit from bases
                         group=getattr(cls, "_group", ""),
                         hideable=getattr(cls, "_hideable", False),
+                        test_with=_get_name(getattr(cls, "_test_with", None)),
                         # in the following we don't use `getattr` to avoid inheriting
                         pragmas=cls.__dict__.get("_pragmas", []),
                         synth=cls.__dict__.get("_synth", None),
@@ -107,6 +116,13 @@ def _fill_hideable_information(classes: typing.Dict[str, schema.Class]):
                 todo.append(supercls)
 
 
+def _check_test_with(classes: typing.Dict[str, schema.Class]):
+    for cls in classes.values():
+        if cls.test_with is not None and classes[cls.test_with].test_with is not None:
+            raise schema.Error(f"{cls.name} has test_with {cls.test_with} which in turn "
+                               f"has test_with {classes[cls.test_with].test_with}, use that directly")
+
+
 def load(m: types.ModuleType) -> schema.Schema:
     includes = set()
     classes = {}
@@ -136,6 +152,7 @@ def load(m: types.ModuleType) -> schema.Schema:
 
     _fill_synth_information(classes)
     _fill_hideable_information(classes)
+    _check_test_with(classes)
 
     return schema.Schema(includes=includes, classes=_toposort_classes_by_group(classes), null=null)
 

misc/codegen/test/test_qlgen.py

@@ -688,6 +688,18 @@ def test_test_class_hierarchy_uncollapse_at_final(opts, generate_tests):
     }
 
 
+def test_test_with(opts, generate_tests):
+    write(opts.ql_test_output / "B" / "test.swift")
+    assert generate_tests([
+        schema.Class("Base", derived={"A", "B"}),
+        schema.Class("A", bases=["Base"], test_with="B"),
+        schema.Class("B", bases=["Base"]),
+    ]) == {
+        "B/A.ql": a_ql_class_tester(class_name="A"),
+        "B/B.ql": a_ql_class_tester(class_name="B"),
+    }
+
+
 def test_property_description(generate_classes):
     description = ["Lorem", "Ipsum"]
     assert generate_classes([

misc/codegen/test/test_schemaloader.py

@@ -727,5 +727,83 @@ class NonHideable(Root):
     }
 
 
+def test_test_with():
+    @load
+    class data:
+        class Root:
+            pass
+
+        class A(Root):
+            pass
+
+        @defs.qltest.test_with(A)
+        class B(Root):
+            pass
+
+        @defs.qltest.test_with("D")
+        class C(Root):
+            pass
+
+        class D(Root):
+            pass
+
+    assert data.classes == {
+        "Root": schema.Class("Root", derived=set("ABCD")),
+        "A": schema.Class("A", bases=["Root"]),
+        "B": schema.Class("B", bases=["Root"], test_with="A"),
+        "C": schema.Class("C", bases=["Root"], test_with="D"),
+        "D": schema.Class("D", bases=["Root"]),
+    }
+
+
+def test_test_with_unknown_string():
+    with pytest.raises(schema.Error):
+        @load
+        class data:
+            class Root:
+                pass
+
+            @defs.qltest.test_with("B")
+            class A(Root):
+                pass
+
+
+def test_test_with_unknown_class():
+    with pytest.raises(schema.Error):
+        class B:
+            pass
+
+        @load
+        class data:
+            class Root:
+                pass
+
+            @defs.qltest.test_with(B)
+            class A(Root):
+                pass
+
+
+def test_test_with_double():
+    with pytest.raises(schema.Error):
+        class B:
+            pass
+
+        @load
+        class data:
+            class Root:
+                pass
+
+            class A(Root):
+                pass
+
+            @defs.qltest.test_with("C")
+            class B(Root):
+                pass
+
+            @defs.qltest.test_with(A)
+            class C(Root):
+                pass
+
+
 if __name__ == '__main__':
     sys.exit(pytest.main([__file__] + sys.argv[1:]))

swift/ql/.generated.list

@@ -0,0 +1,12 @@
+| enums.swift:2:5:2:18 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 2 |
+| enums.swift:3:5:3:26 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 3 |
+| enums.swift:8:5:8:18 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 2 |
+| enums.swift:9:5:9:26 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 3 |
+| enums.swift:13:5:13:22 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:14:5:14:21 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:15:5:15:35 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:19:5:19:10 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:20:5:20:16 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:24:5:24:25 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:25:5:25:24 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |
+| enums.swift:26:5:26:44 | case ... | getModule: | file://:0:0:0:0 | enums | getNumberOfMembers: | 0 | getNumberOfElements: | 1 |