Swift: parametrize namespace and other things in codegen

This is so that we can use this in the PoC branch.

Author: redsun82

swift/codegen/cppgen.py

@@ -1,7 +1,7 @@
 import functools
-import inflection
 from typing import Dict
 
+import inflection
 from toposort import toposort_flatten
 
 from swift.codegen.lib import cpp, generator, schema
@@ -20,7 +20,7 @@ def _get_type(t: str) -> str:
 def _get_field(cls: schema.Class, p: schema.Property) -> cpp.Field:
     trap_name = None
     if not p.is_single:
-        trap_name = inflection.pluralize(inflection.camelize(f"{cls.name}_{p.name}")) + "Trap"
+        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),
@@ -41,7 +41,7 @@ def _get_class(self, name: str) -> cpp.Class:
         cls = self._classmap[name]
         trap_name = None
         if not cls.derived or any(p.is_single for p in cls.properties):
-            trap_name = inflection.pluralize(cls.name) + "Trap"
+            trap_name = inflection.pluralize(cls.name)
         return cpp.Class(
             name=name,
             bases=[self._get_class(b) for b in cls.bases],
@@ -58,7 +58,8 @@ def get_classes(self):
 def generate(opts, renderer):
     processor = Processor({cls.name: cls for cls in schema.load(opts.schema).classes})
     out = opts.cpp_output
-    renderer.render(cpp.ClassList(processor.get_classes()), out / "TrapClasses.h")
+    renderer.render(cpp.ClassList(processor.get_classes(), opts.cpp_namespace, opts.trap_suffix,
+                                  opts.cpp_include_dir), out / "TrapClasses.h")
 
 
 tags = ("cpp", "schema")

swift/codegen/lib/cpp.py

@@ -105,14 +105,18 @@ def has_bases(self):
 class TrapList:
     template: ClassVar = 'trap_traps'
 
-    traps: List[Trap] = field(default_factory=list)
+    traps: List[Trap]
+    namespace: str
+    trap_suffix: str
+    include_dir: str
 
 
 @dataclass
 class TagList:
     template: ClassVar = 'trap_tags'
 
-    tags: List[Tag] = field(default_factory=list)
+    tags: List[Tag]
+    namespace: str
 
 
 @dataclass
@@ -148,3 +152,6 @@ class ClassList:
     template: ClassVar = "cpp_classes"
 
     classes: List[Class]
+    namespace: str
+    trap_suffix: str
+    include_dir: str

swift/codegen/lib/options.py

@@ -16,6 +16,9 @@ def _init_options():
     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("--cpp-include-dir", tags=["cpp"], required=True)
 
 
 def _abspath(x):

swift/codegen/templates/cpp_classes.mustache

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

swift/codegen/templates/trap_tags.mustache

@@ -2,7 +2,7 @@
 // clang-format off
 #pragma once
 
-namespace codeql {
+namespace {{namespace}} {
 {{#tags}}
 
 // {{id}}

swift/codegen/templates/trap_traps.mustache

@@ -5,14 +5,14 @@
 #include <iostream>
 #include <string>
 
-#include "swift/extractor/trap/TrapLabel.h"
-#include "swift/extractor/trap/TrapTags.h"
+#include "{{include_dir}}/TrapLabel.h"
+#include "{{include_dir}}/TrapTags.h"
 
-namespace codeql {
+namespace {{namespace}} {
 {{#traps}}
 
 // {{table_name}}
-struct {{name}}Trap {
+struct {{name}}{{trap_suffix}} {
   static constexpr bool is_binding = {{#id}}true{{/id}}{{^id}}false{{/id}};
 {{#id}}
   {{type}} getBoundLabel() const { return {{cpp_name}}; }

swift/codegen/test/test_cppgen.py

@@ -10,13 +10,19 @@
 @pytest.fixture
 def generate(opts, renderer, input):
     opts.cpp_output = output_dir
+    opts.cpp_namespace = "test_namespace"
+    opts.trap_suffix = "TestTrapSuffix"
+    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 isinstance(generated, cpp.ClassList)
+        assert generated.namespace == opts.cpp_namespace
+        assert generated.trap_suffix == opts.trap_suffix
+        assert generated.include_dir == opts.cpp_include_dir
         return generated.classes
 
     return ret
@@ -30,7 +36,7 @@ def test_empty_class(generate):
     assert generate([
         schema.Class(name="MyClass"),
     ]) == [
-        cpp.Class(name="MyClass", final=True, trap_name="MyClassesTrap")
+        cpp.Class(name="MyClass", final=True, trap_name="MyClasses")
     ]
 
 
@@ -41,7 +47,7 @@ def test_two_class_hierarchy(generate):
         schema.Class(name="B", bases={"A"}),
     ]) == [
         base,
-        cpp.Class(name="B", bases=[base], final=True, trap_name="BsTrap"),
+        cpp.Class(name="B", bases=[base], final=True, trap_name="Bs"),
     ]
 
 
@@ -50,8 +56,8 @@ def test_complex_hierarchy_topologically_ordered(generate):
     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="EsTrap")
-    f = cpp.Class(name="F", bases=[c], final=True, trap_name="FsTrap")
+    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"}),
@@ -70,9 +76,9 @@ def test_complex_hierarchy_topologically_ordered(generate):
 ])
 @pytest.mark.parametrize("property_cls,optional,repeated,trap_name", [
     (schema.SingleProperty, False, False, None),
-    (schema.OptionalProperty, True, False, "MyClassPropsTrap"),
-    (schema.RepeatedProperty, False, True, "MyClassPropsTrap"),
-    (schema.RepeatedOptionalProperty, True, True, "MyClassPropsTrap"),
+    (schema.OptionalProperty, True, False, "MyClassProps"),
+    (schema.RepeatedProperty, False, True, "MyClassProps"),
+    (schema.RepeatedOptionalProperty, True, True, "MyClassProps"),
 ])
 def test_class_with_field(generate, type, expected, property_cls, optional, repeated, trap_name):
     assert generate([
@@ -81,7 +87,7 @@ def test_class_with_field(generate, type, expected, property_cls, optional, repe
         cpp.Class(name="MyClass",
                   fields=[cpp.Field("prop", expected, is_optional=optional,
                                     is_repeated=repeated, trap_name=trap_name)],
-                  trap_name="MyClassesTrap",
+                  trap_name="MyClasses",
                   final=True)
     ]
 
@@ -94,7 +100,7 @@ def test_class_with_overridden_unsigned_field(generate, name):
     ]) == [
         cpp.Class(name="MyClass",
                   fields=[cpp.Field(name, "unsigned")],
-                  trap_name="MyClassesTrap",
+                  trap_name="MyClasses",
                   final=True)
     ]
 
@@ -106,7 +112,7 @@ def test_class_with_overridden_underscore_field(generate):
     ]) == [
         cpp.Class(name="MyClass",
                   fields=[cpp.Field("something", "bar")],
-                  trap_name="MyClassesTrap",
+                  trap_name="MyClasses",
                   final=True)
     ]
 
@@ -119,7 +125,7 @@ def test_class_with_keyword_field(generate, name):
     ]) == [
         cpp.Class(name="MyClass",
                   fields=[cpp.Field(name + "_", "bar")],
-                  trap_name="MyClassesTrap",
+                  trap_name="MyClasses",
                   final=True)
     ]
 

swift/codegen/test/test_trapgen.py

@@ -10,6 +10,9 @@
 @pytest.fixture
 def generate(opts, renderer, dbscheme_input):
     opts.cpp_output = output_dir
+    opts.cpp_namespace = "test_namespace"
+    opts.trap_suffix = "TrapSuffix"
+    opts.cpp_include_dir = "my/include/dir"
 
     def ret(entities):
         dbscheme_input.entities = entities
@@ -22,27 +25,35 @@ def ret(entities):
 
 
 @pytest.fixture
-def generate_traps(generate):
+def generate_traps(opts, generate):
     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.include_dir == opts.cpp_include_dir
         return traps.traps
 
     return ret
 
 
 @pytest.fixture
-def generate_tags(generate):
+def generate_tags(opts, generate):
     def ret(entities):
         _, tags = generate(entities)
         assert isinstance(tags, cpp.TagList)
+        assert tags.namespace == opts.cpp_namespace
         return tags.tags
 
     return ret
 
 
-def test_empty(generate):
-    assert generate([]) == (cpp.TrapList([]), cpp.TagList([]))
+def test_empty_traps(generate_traps):
+    assert generate_traps([]) == []
+
+
+def test_empty_tags(generate_tags):
+    assert generate_tags([]) == []
 
 
 def test_one_empty_table_rejected(generate_traps):

swift/codegen/trapgen.py

@@ -1,14 +1,12 @@
 #!/usr/bin/env python3
 
 import logging
-import re
 
 import inflection
 from toposort import toposort_flatten
 
 from swift.codegen.lib import dbscheme, generator, cpp
 
-
 log = logging.getLogger(__name__)
 
 
@@ -70,7 +68,8 @@ def generate(opts, renderer):
             for d in e.rhs:
                 tag_graph.setdefault(d.type, set()).add(e.lhs)
 
-    renderer.render(cpp.TrapList(traps), out / "TrapEntries.h")
+    renderer.render(cpp.TrapList(traps, opts.cpp_namespace, opts.trap_suffix, opts.cpp_include_dir),
+                    out / "TrapEntries.h")
 
     tags = []
     for index, tag in enumerate(toposort_flatten(tag_graph)):
@@ -80,7 +79,7 @@ def generate(opts, renderer):
             index=index,
             id=tag,
         ))
-    renderer.render(cpp.TagList(tags), out / "TrapTags.h")
+    renderer.render(cpp.TagList(tags, opts.cpp_namespace), out / "TrapTags.h")
 
 
 tags = ("cpp", "dbscheme")

swift/extractor/trap/BUILD.bazel

@@ -5,7 +5,12 @@ genrule(
         "TrapEntries.h",
         "TrapTags.h",
     ],
-    cmd = "$(location //swift/codegen:trapgen) --dbscheme $< --cpp-output $(RULEDIR)",
+    cmd = " ".join([
+        "$(location //swift/codegen:trapgen)",
+        "--dbscheme $<",
+        "--cpp-include-dir " + package_name(),
+        "--cpp-output $(RULEDIR)",
+    ]),
     exec_tools = ["//swift/codegen:trapgen"],
 )
 
@@ -18,7 +23,12 @@ genrule(
     outs = [
         "TrapClasses.h",
     ],
-    cmd = "$(location //swift/codegen:cppgen) --schema $(location //swift/codegen:schema) --cpp-output $(RULEDIR)",
+    cmd = " ".join([
+        "$(location //swift/codegen:cppgen)",
+        "--schema $(location //swift/codegen:schema)",
+        "--cpp-include-dir " + package_name(),
+        "--cpp-output $(RULEDIR)",
+    ]),
     exec_tools = ["//swift/codegen:cppgen"],
 )