Merge pull request #9100 from redsun82/swift-tbd-rework

Swift: changes required for TBD node rework

Author: MathiasVP

swift/codegen/cppgen.py

@@ -27,7 +27,7 @@ def _get_field(cls: schema.Class, p: schema.Property, trap_affix: str) -> cpp.Fi
         if not p.is_predicate:
             trap_name = inflection.pluralize(trap_name)
     args = dict(
-        name=p.name + ("_" if p.name in cpp.cpp_keywords else ""),
+        field_name=p.name + ("_" if p.name in cpp.cpp_keywords else ""),
         type=_get_type(p.type, trap_affix),
         is_optional=p.is_optional,
         is_repeated=p.is_repeated,

swift/codegen/lib/cpp.py

@@ -17,7 +17,7 @@
 
 _field_overrides = [
     (re.compile(r"(start|end)_(line|column)|index|width|num_.*"), {"type": "unsigned"}),
-    (re.compile(r"(.*)_"), lambda m: {"name": m[1]}),
+    (re.compile(r"(.*)_"), lambda m: {"field_name": m[1]}),
 ]
 
 
@@ -31,7 +31,7 @@ def get_field_override(field: str):
 
 @dataclass
 class Field:
-    name: str
+    field_name: str
     type: str
     is_optional: bool = False
     is_repeated: bool = False
@@ -44,12 +44,8 @@ def __post_init__(self):
             self.type = f"std::optional<{self.type}>"
         if self.is_repeated:
             self.type = f"std::vector<{self.type}>"
-
-    @property
-    def cpp_name(self):
-        if self.name in cpp_keywords:
-            return self.name + "_"
-        return self.name
+        if self.field_name in cpp_keywords:
+            self.field_name += "_"
 
     # using @property breaks pystache internals here
     def get_streamer(self):
@@ -65,8 +61,6 @@ def is_single(self):
         return not (self.is_optional or self.is_repeated or self.is_predicate)
 
 
-
-
 @dataclass
 class Trap:
     table_name: str

swift/codegen/lib/schema.py

@@ -92,7 +92,6 @@ def load(path):
         data = yaml.load(input, Loader=yaml.SafeLoader)
     grouper = _DirSelector(data.get("_directories", {}).items())
     classes = {root_class_name: Class(root_class_name)}
-    assert root_class_name not in data
     classes.update((cls, Class(cls, dir=grouper.get(cls))) for cls in data if not cls.startswith("_"))
     for name, info in data.items():
         if name.startswith("_"):
@@ -110,7 +109,7 @@ def load(path):
                     classes[base].derived.add(name)
             elif k == "_dir":
                 cls.dir = pathlib.Path(v)
-        if not cls.bases:
+        if not cls.bases and cls.name != root_class_name:
             cls.bases.add(root_class_name)
             classes[root_class_name].derived.add(name)
 

swift/codegen/templates/cpp_classes.mustache

@@ -14,7 +14,7 @@ namespace {{namespace}} {
 
 struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases}}{{/final}}{{^final}}{{#has_bases}}: {{#bases}}{{^first}}, {{/first}}{{ref.name}}{{/bases}}{{/has_bases}}{{/final}} {
   {{#fields}}
-  {{type}} {{name}}{};
+  {{type}} {{field_name}}{};
   {{/fields}}
   {{#final}}
 
@@ -27,27 +27,27 @@ struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases
  protected:
   void emit({{^final}}{{trap_affix}}Label<{{name}}Tag> id, {{/final}}std::ostream& out) const {
     {{#trap_name}}
-    out << {{.}}{{trap_affix}}{id{{#single_fields}}, {{name}}{{/single_fields}}} << '\n';
+    out << {{.}}{{trap_affix}}{id{{#single_fields}}, {{field_name}}{{/single_fields}}} << '\n';
     {{/trap_name}}
     {{#bases}}
     {{ref.name}}::emit(id, out);
     {{/bases}}
     {{#fields}}
     {{#is_predicate}}
-    if ({{name}}) out << {{trap_name}}{{trap_affix}}{id} << '\n';
+    if ({{field_name}}) out << {{trap_name}}{{trap_affix}}{id} << '\n';
     {{/is_predicate}}
     {{#is_optional}}
     {{^is_repeated}}
-    if ({{name}}) out << {{trap_name}}{{trap_affix}}{id, *{{name}}} << '\n';
+    if ({{field_name}}) out << {{trap_name}}{{trap_affix}}{id, *{{field_name}}} << '\n';
     {{/is_repeated}}
     {{/is_optional}}
     {{#is_repeated}}
-    for (auto i = 0u; i < {{name}}.size(); ++i) {
+    for (auto i = 0u; i < {{field_name}}.size(); ++i) {
       {{^is_optional}}
-      out << {{trap_name}}{{trap_affix}}{id, i, {{name}}[i]};
+      out << {{trap_name}}{{trap_affix}}{id, i, {{field_name}}[i]};
       {{/is_optional}}
       {{#is_optional}}
-      if ({{name}}[i]) out << {{trap_name}}{{trap_affix}}{id, i, *{{name}}[i]};
+      if ({{field_name}}[i]) out << {{trap_name}}{{trap_affix}}{id, i, *{{field_name}}[i]};
       {{/is_optional}}
     }
     {{/is_repeated}}

swift/codegen/templates/ql_class.mustache

@@ -8,6 +8,10 @@ class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
   {{#root}}
   string toString() { none() } // overridden by subclasses
 
+  string getAPrimaryQlClass() { none() } // overridden by subclasses
+
+  final string getPrimaryQlClasses() { result = concat(this.getAPrimaryQlClass(), ",") }
+
   {{name}}Base getResolveStep() { none() } // overridden by subclasses
 
   {{name}}Base resolve() {
@@ -17,7 +21,7 @@ class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
   }
   {{/root}}
   {{#final}}
-  override string toString() { result = "{{name}}" }
+  override string getAPrimaryQlClass() { result = "{{name}}" }
   {{/final}}
   {{#properties}}
 
@@ -32,6 +36,12 @@ class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
     {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
     {{/type_is_class}}
   }
+  {{#is_optional}}
+
+  predicate has{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
+    exists({{getter}}({{#is_repeated}}index{{/is_repeated}}))
+  }
+  {{/is_optional}}
   {{#is_repeated}}
 
   {{type}} {{indefinite_getter}}() {

swift/codegen/templates/trap_traps.mustache

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "{{include_dir}}/{{trap_affix}}Label.h"
+#include "{{include_dir}}/{{trap_affix}}TagTraits.h"
 #include "./{{trap_affix}}Tags.h"
 
 namespace {{namespace}} {
@@ -15,19 +16,25 @@ namespace {{namespace}} {
 struct {{name}}{{trap_affix}} {
   static constexpr bool is_binding = {{#id}}true{{/id}}{{^id}}false{{/id}};
 {{#id}}
-  {{type}} getBoundLabel() const { return {{cpp_name}}; }
+  {{type}} getBoundLabel() const { return {{field_name}}; }
 {{/id}}
 
 {{#fields}}
-  {{type}} {{cpp_name}}{};
+  {{type}} {{field_name}}{};
 {{/fields}}
 };
 
 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}} << ")";
+      << {{#get_streamer}}e.{{field_name}}{{/get_streamer}}{{/fields}} << ")";
   return out;
 }
-{{/traps}}
+{{#id}}
 
+template <>
+struct TagToBindingTrapFunctor<typename {{type}}::Tag> {
+  using type = {{name}}{{trap_affix}};
+};
+{{/id}}
+{{/traps}}
 }

swift/codegen/test/test_cpp.py

@@ -7,14 +7,14 @@
 
 
 @pytest.mark.parametrize("keyword", cpp.cpp_keywords)
-def test_field_keyword_cpp_name(keyword):
+def test_field_keyword_name(keyword):
     f = cpp.Field(keyword, "int")
-    assert f.cpp_name == keyword + "_"
+    assert f.field_name == keyword + "_"
 
 
-def test_field_cpp_name():
+def test_field_name():
     f = cpp.Field("foo", "int")
-    assert f.cpp_name == "foo"
+    assert f.field_name == "foo"
 
 
 @pytest.mark.parametrize("type,expected", [

swift/codegen/test/test_schema.py

@@ -155,5 +155,17 @@ def test_properties(load):
     ]
 
 
+def test_element_properties(load):
+    ret = load("""
+Element:
+    x: string
+""")
+    assert ret.classes == [
+        schema.Class(root_name, properties=[
+            schema.SingleProperty('x', 'string'),
+         ]),
+    ]
+
+
 if __name__ == '__main__':
     sys.exit(pytest.main([__file__] + sys.argv[1:]))

swift/codegen/trapgen.py

@@ -28,7 +28,7 @@ def get_cpp_type(schema_type: str, trap_affix: str):
 
 def get_field(c: dbscheme.Column, trap_affix: str):
     args = {
-        "name": c.schema_name,
+        "field_name": c.schema_name,
         "type": c.type,
     }
     args.update(cpp.get_field_override(c.schema_name))

swift/extractor/trap/TrapLabel.h

@@ -27,14 +27,16 @@ class UntypedTrapLabel {
   friend bool operator==(UntypedTrapLabel lhs, UntypedTrapLabel rhs) { return lhs.id_ == rhs.id_; }
 };
 
-template <typename Tag>
+template <typename TagParam>
 class TrapLabel : public UntypedTrapLabel {
   template <typename OtherTag>
   friend class TrapLabel;
 
   using UntypedTrapLabel::UntypedTrapLabel;
 
  public:
+  using Tag = TagParam;
+
   TrapLabel() = default;
 
   template <typename OtherTag>