hohn/codeql
1
0
Fork 0
mirror of https://github.com/github/codeql.git synced 2026-05-05 13:45:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

Swift: preserve base order in code generation

Browse Source
This commit is contained in:
Paolo Tranquilli
2022-08-31 10:43:31 +02:00
parent 9545598daf
commit 3ce76e6c08
12 changed files with 108 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
swift/codegen/test/test_cppgen.py
View File

@@ -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")),
]) == {

2
swift/codegen/test/test_ql.py
View File

@@ -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

58
swift/codegen/test/test_qlgen.py
View File

@@ -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"),

52
swift/codegen/test/test_schema.py
View File

@@ -30,7 +30,7 @@ MyClass: {}
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'MyClass'}),
'MyClass': schema.Class('MyClass', bases={root_name}),
'MyClass': schema.Class('MyClass', bases=[root_name]),
}
@@ -41,8 +41,8 @@ MyClass2: {}
""")
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}),
'MyClass1': schema.Class('MyClass1', bases=[root_name]),
'MyClass2': schema.Class('MyClass2', bases=[root_name]),
}
@@ -54,8 +54,8 @@ MyClass2:
""")
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'}),
'MyClass1': schema.Class('MyClass1', bases=[root_name], derived={'MyClass2'}),
'MyClass2': schema.Class('MyClass2', bases=['MyClass1']),
}
@@ -70,9 +70,9 @@ C:
""")
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'}),
'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']),
}
@@ -83,7 +83,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
'A': schema.Class('A', bases=[root_name], dir=pathlib.Path("other/dir")),
}
@@ -103,13 +103,13 @@ A: {}
""")
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()),
'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()),
}
@@ -122,7 +122,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
'A': schema.Class('A', bases=[root_name], dir=pathlib.Path("other/dir")),
}
@@ -147,7 +147,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.SingleProperty('one', 'string'),
schema.OptionalProperty('two', 'int'),
schema.RepeatedProperty('three', 'bool'),
@@ -182,7 +182,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.SingleProperty('a', 'string'),
schema.RepeatedProperty('b', 'B'),
schema.SingleProperty('c', 'C', is_child=True),
@@ -211,7 +211,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.RepeatedProperty('x', 'string'),
]),
}
@@ -226,7 +226,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.RepeatedProperty('x', 'string', pragmas=["foo", "bar"]),
]),
}
@@ -241,7 +241,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.RepeatedProperty('x', 'string', pragmas=["foo"]),
]),
}
@@ -274,7 +274,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.RepeatedProperty('x', 'string'),
], pragmas=["foo", "bar"]),
}
@@ -288,7 +288,7 @@ A:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'A'}),
'A': schema.Class('A', bases={root_name}, properties=[
'A': schema.Class('A', bases=[root_name], properties=[
schema.RepeatedProperty('x', 'string'),
], pragmas=["foo"]),
}
@@ -311,7 +311,7 @@ MyClass:
""")
assert ret.classes == {
root_name: schema.Class(root_name, derived={'MyClass'}),
'MyClass': schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(from_class="A")),
'MyClass': schema.Class('MyClass', bases=[root_name], ipa=schema.IpaInfo(from_class="A")),
}
@@ -325,7 +325,7 @@ MyClass:
""")
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"})),
'MyClass': schema.Class('MyClass', bases=[root_name], ipa=schema.IpaInfo(on_arguments={"x": "A", "y": "int"})),
}