Swift: add more parametrization

This enables codegen to run on the swift PoC branch.

Author: redsun82

swift/codegen/cppgen.py

@@ -7,23 +7,23 @@
 from swift.codegen.lib import cpp, generator, schema
 
 
-def _get_type(t: str) -> str:
+def _get_type(t: str, trap_affix: str) -> str:
     if t == "string":
         return "std::string"
     if t == "boolean":
         return "bool"
     if t[0].isupper():
-        return f"TrapLabel<{t}Tag>"
+        return f"{trap_affix}Label<{t}Tag>"
     return t
 
 
-def _get_field(cls: schema.Class, p: schema.Property) -> cpp.Field:
+def _get_field(cls: schema.Class, p: schema.Property, trap_affix: str) -> cpp.Field:
     trap_name = None
     if not p.is_single:
         trap_name = inflection.pluralize(inflection.camelize(f"{cls.name}_{p.name}"))
     args = dict(
         name=p.name + ("_" if p.name in cpp.cpp_keywords else ""),
-        type=_get_type(p.type),
+        type=_get_type(p.type, trap_affix),
         is_optional=p.is_optional,
         is_repeated=p.is_repeated,
         trap_name=trap_name,
@@ -33,8 +33,9 @@ def _get_field(cls: schema.Class, p: schema.Property) -> cpp.Field:
 
 
 class Processor:
-    def __init__(self, data: Dict[str, schema.Class]):
+    def __init__(self, data: Dict[str, schema.Class], trap_affix: str):
         self._classmap = data
+        self._trap_affix = trap_affix
 
     @functools.lru_cache(maxsize=None)
     def _get_class(self, name: str) -> cpp.Class:
@@ -45,7 +46,7 @@ def _get_class(self, name: str) -> cpp.Class:
         return cpp.Class(
             name=name,
             bases=[self._get_class(b) for b in cls.bases],
-            fields=[_get_field(cls, p) for p in cls.properties],
+            fields=[_get_field(cls, p, self._trap_affix) for p in cls.properties],
             final=not cls.derived,
             trap_name=trap_name,
         )
@@ -56,10 +57,10 @@ def get_classes(self):
 
 
 def generate(opts, renderer):
-    processor = Processor({cls.name: cls for cls in schema.load(opts.schema).classes})
+    processor = Processor({cls.name: cls for cls in schema.load(opts.schema).classes}, opts.trap_affix)
     out = opts.cpp_output
-    renderer.render(cpp.ClassList(processor.get_classes(), opts.cpp_namespace, opts.trap_suffix,
-                                  opts.cpp_include_dir), out / "TrapClasses.h")
+    renderer.render(cpp.ClassList(processor.get_classes(), opts.cpp_namespace, opts.trap_affix,
+                                  opts.cpp_include_dir), out / f"{opts.trap_affix}Classes.h")
 
 
 tags = ("cpp", "schema")

swift/codegen/dbschemegen.py

@@ -63,12 +63,12 @@ def get_declarations(data: schema.Schema):
     return [d for cls in data.classes for d in cls_to_dbscheme(cls)]
 
 
-def get_includes(data: schema.Schema, include_dir: pathlib.Path):
+def get_includes(data: schema.Schema, include_dir: pathlib.Path, swift_dir: pathlib.Path):
     includes = []
     for inc in data.includes:
         inc = include_dir / inc
         with open(inc) as inclusion:
-            includes.append(SchemeInclude(src=inc.relative_to(paths.swift_dir), data=inclusion.read()))
+            includes.append(SchemeInclude(src=inc.relative_to(swift_dir), data=inclusion.read()))
     return includes
 
 
@@ -78,8 +78,8 @@ def generate(opts, renderer):
 
     data = schema.load(input)
 
-    dbscheme = Scheme(src=input.relative_to(paths.swift_dir),
-                      includes=get_includes(data, include_dir=input.parent),
+    dbscheme = Scheme(src=input.relative_to(opts.swift_dir),
+                      includes=get_includes(data, include_dir=input.parent, swift_dir=opts.swift_dir),
                       declarations=get_declarations(data))
 
     renderer.render(dbscheme, out)

swift/codegen/lib/cpp.py

@@ -107,7 +107,7 @@ class TrapList:
 
     traps: List[Trap]
     namespace: str
-    trap_suffix: str
+    trap_affix: str
     include_dir: str
 
 
@@ -153,5 +153,5 @@ class ClassList:
 
     classes: List[Class]
     namespace: str
-    trap_suffix: str
+    trap_affix: str
     include_dir: str

swift/codegen/lib/options.py

@@ -10,14 +10,15 @@
 
 def _init_options():
     Option("--verbose", "-v", action="store_true")
+    Option("--swift-dir", type=_abspath, default=paths.swift_dir)
     Option("--schema", tags=["schema"], type=_abspath, default=paths.swift_dir / "codegen/schema.yml")
     Option("--dbscheme", tags=["dbscheme"], type=_abspath, default=paths.swift_dir / "ql/lib/swift.dbscheme")
     Option("--ql-output", tags=["ql"], type=_abspath, default=paths.swift_dir / "ql/lib/codeql/swift/generated")
     Option("--ql-stub-output", tags=["ql"], type=_abspath, default=paths.swift_dir / "ql/lib/codeql/swift/elements")
     Option("--codeql-binary", tags=["ql"], default="codeql")
     Option("--cpp-output", tags=["cpp"], type=_abspath, required=True)
     Option("--cpp-namespace", tags=["cpp"], default="codeql")
-    Option("--trap-suffix", tags=["cpp"], default="Trap")
+    Option("--trap-affix", tags=["cpp"], default="Trap")
     Option("--cpp-include-dir", tags=["cpp"], required=True)
 
 

swift/codegen/qlgen.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python3
 
 import logging
+import pathlib
 import subprocess
 
 import inflection
@@ -47,8 +48,8 @@ def get_ql_class(cls: schema.Class):
     )
 
 
-def get_import(file):
-    stem = file.relative_to(paths.swift_dir / "ql/lib").with_suffix("")
+def get_import(file: pathlib.Path, swift_dir: pathlib.Path):
+    stem = file.relative_to(swift_dir / "ql/lib").with_suffix("")
     return str(stem).replace("/", ".")
 
 
@@ -89,15 +90,15 @@ def generate(opts, renderer):
     imports = {}
 
     for c in classes:
-        imports[c.name] = get_import(stub_out / c.path)
+        imports[c.name] = get_import(stub_out / c.path, opts.swift_dir)
 
     for c in classes:
         qll = (out / c.path).with_suffix(".qll")
         c.imports = [imports[t] for t in get_classes_used_by(c)]
         renderer.render(c, qll)
         stub_file = (stub_out / c.path).with_suffix(".qll")
         if not stub_file.is_file() or is_generated(stub_file):
-            stub = ql.Stub(name=c.name, base_import=get_import(qll))
+            stub = ql.Stub(name=c.name, base_import=get_import(qll, opts.swift_dir))
             renderer.render(stub, stub_file)
 
     # for example path/to/syntax/generated -> path/to/syntax.qll

swift/codegen/templates/cpp_classes.mustache

@@ -6,8 +6,8 @@
 #include <optional>
 #include <vector>
 
-#include "{{include_dir}}/TrapLabel.h"
-#include "./TrapEntries.h"
+#include "{{include_dir}}/{{trap_affix}}Label.h"
+#include "./{{trap_affix}}Entries.h"
 
 namespace {{namespace}} {
 {{#classes}}
@@ -30,21 +30,21 @@ struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases
     {{ref.name}}::emit(id, out);
     {{/bases}}
     {{#trap_name}}
-    out << {{.}}{{trap_suffix}}{id{{#single_fields}}, {{name}}{{/single_fields}}} << '\n';
+    out << {{.}}{{trap_affix}}{id{{#single_fields}}, {{name}}{{/single_fields}}} << '\n';
     {{/trap_name}}
     {{#fields}}
     {{#is_optional}}
     {{^is_repeated}}
-    if ({{name}}) out << {{trap_name}}{{trap_suffix}}{id, *{{name}}} << '\n';
+    if ({{name}}) out << {{trap_name}}{{trap_affix}}{id, *{{name}}} << '\n';
     {{/is_repeated}}
     {{/is_optional}}
     {{#is_repeated}}
     for (auto i = 0u; i < {{name}}.size(); ++i) {
       {{^is_optional}}
-      out << {{trap_name}}{{trap_suffix}}{id, i, {{name}}[i]};
+      out << {{trap_name}}{{trap_affix}}{id, i, {{name}}[i]};
       {{/is_optional}}
       {{#is_optional}}
-      if ({{name}}[i]) out << {{trap_name}}{{trap_suffix}}{id, i, *{{name}}[i]};
+      if ({{name}}[i]) out << {{trap_name}}{{trap_affix}}{id, i, *{{name}}[i]};
       {{/is_optional}}
     }
     {{/is_repeated}}

swift/codegen/templates/trap_traps.mustache

@@ -5,14 +5,14 @@
 #include <iostream>
 #include <string>
 
-#include "{{include_dir}}/TrapLabel.h"
-#include "./TrapTags.h"
+#include "{{include_dir}}/{{trap_affix}}Label.h"
+#include "./{{trap_affix}}Tags.h"
 
 namespace {{namespace}} {
 {{#traps}}
 
 // {{table_name}}
-struct {{name}}{{trap_suffix}} {
+struct {{name}}{{trap_affix}} {
   static constexpr bool is_binding = {{#id}}true{{/id}}{{^id}}false{{/id}};
 {{#id}}
   {{type}} getBoundLabel() const { return {{cpp_name}}; }
@@ -23,7 +23,7 @@ struct {{name}}{{trap_suffix}} {
 {{/fields}}
 };
 
-inline std::ostream &operator<<(std::ostream &out, const {{name}}Trap &e) {
+inline std::ostream &operator<<(std::ostream &out, const {{name}}{{trap_affix}} &e) {
   out << "{{table_name}}("{{#fields}}{{^first}} << ", "{{/first}}
       << {{#get_streamer}}e.{{cpp_name}}{{/get_streamer}}{{/fields}} << ")";
   return out;

swift/codegen/test/test_cppgen.py

@@ -11,17 +11,17 @@
 def generate(opts, renderer, input):
     opts.cpp_output = output_dir
     opts.cpp_namespace = "test_namespace"
-    opts.trap_suffix = "TestTrapSuffix"
+    opts.trap_affix = "TestTrapAffix"
     opts.cpp_include_dir = "my/include/dir"
 
     def ret(classes):
         input.classes = classes
         generated = run_generation(cppgen.generate, opts, renderer)
-        assert set(generated) == {output_dir / "TrapClasses.h"}
-        generated = generated[output_dir / "TrapClasses.h"]
+        assert set(generated) == {output_dir / "TestTrapAffixClasses.h"}
+        generated = generated[output_dir / "TestTrapAffixClasses.h"]
         assert isinstance(generated, cpp.ClassList)
         assert generated.namespace == opts.cpp_namespace
-        assert generated.trap_suffix == opts.trap_suffix
+        assert generated.trap_affix == opts.trap_affix
         assert generated.include_dir == opts.cpp_include_dir
         return generated.classes
 
@@ -72,7 +72,7 @@ def test_complex_hierarchy_topologically_ordered(generate):
     ("a", "a"),
     ("string", "std::string"),
     ("boolean", "bool"),
-    ("MyClass", "TrapLabel<MyClassTag>"),
+    ("MyClass", "TestTrapAffixLabel<MyClassTag>"),
 ])
 @pytest.mark.parametrize("property_cls,optional,repeated,trap_name", [
     (schema.SingleProperty, False, False, None),

swift/codegen/test/test_trapgen.py

@@ -11,15 +11,15 @@
 def generate(opts, renderer, dbscheme_input):
     opts.cpp_output = output_dir
     opts.cpp_namespace = "test_namespace"
-    opts.trap_suffix = "TrapSuffix"
+    opts.trap_affix = "TrapAffix"
     opts.cpp_include_dir = "my/include/dir"
 
     def ret(entities):
         dbscheme_input.entities = entities
         generated = run_generation(trapgen.generate, opts, renderer)
         assert set(generated) == {output_dir /
-                                  "TrapEntries.h", output_dir / "TrapTags.h"}
-        return generated[output_dir / "TrapEntries.h"], generated[output_dir / "TrapTags.h"]
+                                  "TrapAffixEntries.h", output_dir / "TrapAffixTags.h"}
+        return generated[output_dir / "TrapAffixEntries.h"], generated[output_dir / "TrapAffixTags.h"]
 
     return ret
 
@@ -30,7 +30,7 @@ def ret(entities):
         traps, _ = generate(entities)
         assert isinstance(traps, cpp.TrapList)
         assert traps.namespace == opts.cpp_namespace
-        assert traps.trap_suffix == opts.trap_suffix
+        assert traps.trap_affix == opts.trap_affix
         assert traps.include_dir == opts.cpp_include_dir
         return traps.traps
 
@@ -106,7 +106,7 @@ def test_one_table_with_two_binding_first_is_id(generate_traps):
 @pytest.mark.parametrize("column,field", [
     (dbscheme.Column("x", "string"), cpp.Field("x", "std::string")),
     (dbscheme.Column("y", "boolean"), cpp.Field("y", "bool")),
-    (dbscheme.Column("z", "@db_type"), cpp.Field("z", "TrapLabel<DbTypeTag>")),
+    (dbscheme.Column("z", "@db_type"), cpp.Field("z", "TrapAffixLabel<DbTypeTag>")),
 ])
 def test_one_table_special_types(generate_traps, column, field):
     assert generate_traps([

swift/codegen/test/utils.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from swift.codegen.lib import render, schema
+from swift.codegen.lib import render, schema, paths
 
 schema_dir = pathlib.Path("a", "dir")
 schema_file = schema_dir / "schema.yml"
@@ -23,7 +23,9 @@ def renderer():
 
 @pytest.fixture
 def opts():
-    return mock.MagicMock()
+    ret = mock.MagicMock()
+    ret.swift_dir = paths.swift_dir
+    return ret
 
 
 @pytest.fixture(autouse=True)