Swift: add ?* modifier to schema specification

redsun82 · redsun82 · commit 9798d8ba26ee · 2022-05-05T11:50:12.000+02:00
This indicates a list of optional entries. This is different than
simply repeatind entries because of the indexing.
diff --git a/swift/codegen/dbschemegen.py b/swift/codegen/dbschemegen.py
@@ -38,24 +38,24 @@ def cls_to_dbscheme(cls: schema.Class):
         )
     # use property-specific tables for 1-to-many and 1-to-at-most-1 properties
     for f in cls.properties:
-        if f.is_optional:
+        if f.is_repeated:
             yield Table(
-                keyset=KeySet(["id"]),
+                keyset=KeySet(["id", "index"]),
                 name=inflection.tableize(f"{cls.name}_{f.name}"),
                 columns=[
                     Column("id", type=dbtype(cls.name)),
-                    Column(f.name, dbtype(f.type)),
-                ],
+                    Column("index", type="int"),
+                    Column(inflection.singularize(f.name), dbtype(f.type)),
+                ]
             )
-        elif f.is_repeated:
+        elif f.is_optional:
             yield Table(
-                keyset=KeySet(["id", "index"]),
+                keyset=KeySet(["id"]),
                 name=inflection.tableize(f"{cls.name}_{f.name}"),
                 columns=[
                     Column("id", type=dbtype(cls.name)),
-                    Column("index", type="int"),
-                    Column(inflection.singularize(f.name), dbtype(f.type)),
-                ]
+                    Column(f.name, dbtype(f.type)),
+                ],
             )
 
 
diff --git a/swift/codegen/lib/cpp.py b/swift/codegen/lib/cpp.py
@@ -41,7 +41,7 @@ class Field:
     def __post_init__(self):
         if self.is_optional:
             self.type = f"std::optional<{self.type}>"
-        elif self.is_repeated:
+        if self.is_repeated:
             self.type = f"std::vector<{self.type}>"
 
     @property
diff --git a/swift/codegen/lib/ql.py b/swift/codegen/lib/ql.py
@@ -22,6 +22,7 @@ class Property:
     params: List[Param] = field(default_factory=list)
     first: bool = False
     local_var: str = "x"
+    is_optional: bool = False
 
     def __post_init__(self):
         if self.params:
@@ -43,6 +44,10 @@ def indefinite_article(self):
     def type_is_class(self):
         return self.type[0].isupper()
 
+    @property
+    def is_repeated(self):
+        return bool(self.plural)
+
 
 @dataclass
 class Class:
diff --git a/swift/codegen/lib/schema.py b/swift/codegen/lib/schema.py
@@ -35,6 +35,12 @@ class RepeatedProperty(Property):
     is_repeated: ClassVar = True
 
 
+@dataclass
+class RepeatedOptionalProperty(Property):
+    is_optional: ClassVar = True
+    is_repeated: ClassVar = True
+
+
 @dataclass
 class Class:
     name: str
@@ -51,7 +57,10 @@ class Schema:
 
 
 def _parse_property(name, type):
-    if type.endswith("*"):
+    if type.endswith("?*"):
+        cls = RepeatedOptionalProperty
+        type = type[:-2]
+    elif type.endswith("*"):
         cls = RepeatedProperty
         type = type[:-1]
     elif type.endswith("?"):
diff --git a/swift/codegen/qlgen.py b/swift/codegen/qlgen.py
@@ -18,13 +18,6 @@ def get_ql_property(cls: schema.Class, prop: schema.Property):
             tablename=inflection.tableize(cls.name),
             tableparams=["this"] + ["result" if p is prop else "_" for p in cls.properties if p.is_single],
         )
-    elif prop.is_optional:
-        return ql.Property(
-            singular=inflection.camelize(prop.name),
-            type=prop.type,
-            tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
-            tableparams=["this", "result"],
-        )
     elif prop.is_repeated:
         return ql.Property(
             singular=inflection.singularize(inflection.camelize(prop.name)),
@@ -33,6 +26,15 @@ def get_ql_property(cls: schema.Class, prop: schema.Property):
             tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
             tableparams=["this", "index", "result"],
             params=[ql.Param("index", type="int")],
+            is_optional=prop.is_optional,
+        )
+    elif prop.is_optional:
+        return ql.Property(
+            singular=inflection.camelize(prop.name),
+            type=prop.type,
+            tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
+            tableparams=["this", "result"],
+            is_optional=True,
         )
 
 
diff --git a/swift/codegen/schema.yml b/swift/codegen/schema.yml
@@ -256,7 +256,7 @@ OperatorDecl:
 
 PatternBindingDecl:
   _extends: Decl
-  inits: Expr*
+  inits: Expr?*
   patterns: Pattern*
 
 PoundDiagnosticDecl:
diff --git a/swift/codegen/templates/cpp_classes.mustache b/swift/codegen/templates/cpp_classes.mustache
@@ -34,10 +34,19 @@ struct {{name}}{{#final}} : Binding<{{name}}Tag>{{#bases}}, {{ref.name}}{{/bases
     {{/trap_name}}
     {{#fields}}
     {{#is_optional}}
+    {{^is_repeated}}
     if ({{name}}) out << {{trap_name}}{id, *{{name}}} << '\n';
+    {{/is_repeated}}
     {{/is_optional}}
     {{#is_repeated}}
-    for (auto i = 0u; i < {{name}}.size(); ++i) out << {{trap_name}}{id, i, {{name}}[i]};
+    for (auto i = 0u; i < {{name}}.size(); ++i) {
+      {{^is_optional}}
+      out << {{trap_name}}{id, i, {{name}}[i]};
+      {{/is_optional}}
+      {{#is_optional}}
+      if ({{name}}[i]) out << {{trap_name}}{id, i, *{{name}}[i]};
+      {{/is_optional}}
+    }
     {{/is_repeated}}
     {{/fields}}
   }
diff --git a/swift/codegen/templates/ql_class.mustache b/swift/codegen/templates/ql_class.mustache
@@ -20,28 +20,28 @@ class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
   {{/final}}
   {{#properties}}
 
-  {{#type_is_class}}
-  {{type}} get{{singular}}({{#params}}{{^first}}, {{/first}}{{type}} {{param}}{{/params}}) {
+  {{type}} get{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
+    {{#type_is_class}}
     exists({{type}} {{local_var}} |
       {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
       and
       result = {{local_var}}.resolve())
-  }
-  {{/type_is_class}}
-  {{^type_is_class}}
-  {{type}} get{{singular}}({{#params}}{{^first}}, {{/first}}{{type}} {{param}}{{/params}}) {
+    {{/type_is_class}}
+    {{^type_is_class}}
     {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
+    {{/type_is_class}}
   }
-  {{/type_is_class}}
-  {{#indefinite_article}}
+  {{#is_repeated}}
 
-  {{type}} get{{.}}{{singular}}() {
-    result = get{{singular}}({{#params}}{{^first}}, {{/first}}_{{/params}})
+  {{type}} get{{indefinite_article}}{{singular}}() {
+    result = get{{singular}}(_)
   }
+  {{^is_optional}}
 
   int getNumberOf{{plural}}() {
-    result = count(get{{.}}{{singular}}())
+    result = count(get{{indefinite_article}}{{singular}}())
   }
-  {{/indefinite_article}}
+  {{/is_optional}}
+  {{/is_repeated}}
   {{/properties}}
 }
diff --git a/swift/codegen/test/test_cpp.py b/swift/codegen/test/test_cpp.py
@@ -42,6 +42,7 @@ def test_field_is_single(is_optional, is_repeated, expected):
     (False, False, "bar"),
     (True, False, "std::optional<bar>"),
     (False, True, "std::vector<bar>"),
+    (True, True, "std::vector<std::optional<bar>>"),
 ])
 def test_field_modal_types(is_optional, is_repeated, expected):
     f = cpp.Field("name", "bar", is_optional=is_optional, is_repeated=is_repeated)
diff --git a/swift/codegen/test/test_cppgen.py b/swift/codegen/test/test_cppgen.py
@@ -72,6 +72,7 @@ def test_complex_hierarchy_topologically_ordered(generate):
     (schema.SingleProperty, False, False, None),
     (schema.OptionalProperty, True, False, "MyClassPropsTrap"),
     (schema.RepeatedProperty, False, True, "MyClassPropsTrap"),
+    (schema.RepeatedOptionalProperty, True, True, "MyClassPropsTrap"),
 ])
 def test_class_with_field(generate, type, expected, property_cls, optional, repeated, trap_name):
     assert generate([
diff --git a/swift/codegen/test/test_dbschemegen.py b/swift/codegen/test/test_dbschemegen.py
@@ -126,10 +126,11 @@ def test_final_class_with_optional_field(opts, input, renderer):
     )
 
 
-def test_final_class_with_repeated_field(opts, input, renderer):
+@pytest.mark.parametrize("property_cls", [schema.RepeatedProperty, schema.RepeatedOptionalProperty])
+def test_final_class_with_repeated_field(opts, input, renderer, property_cls):
     input.classes = [
         schema.Class("Object", properties=[
-            schema.RepeatedProperty("foo", "bar"),
+            property_cls("foo", "bar"),
         ]),
     ]
     assert generate(opts, renderer) == dbscheme.Scheme(
@@ -161,7 +162,8 @@ def test_final_class_with_more_fields(opts, input, renderer):
             schema.SingleProperty("one", "x"),
             schema.SingleProperty("two", "y"),
             schema.OptionalProperty("three", "z"),
-            schema.RepeatedProperty("four", "w"),
+            schema.RepeatedProperty("four", "u"),
+            schema.RepeatedOptionalProperty("five", "v"),
         ]),
     ]
     assert generate(opts, renderer) == dbscheme.Scheme(
@@ -190,7 +192,16 @@ def test_final_class_with_more_fields(opts, input, renderer):
                 columns=[
                     dbscheme.Column('id', '@object'),
                     dbscheme.Column('index', 'int'),
-                    dbscheme.Column('four', 'w'),
+                    dbscheme.Column('four', 'u'),
+                ]
+            ),
+            dbscheme.Table(
+                name="object_fives",
+                keyset=dbscheme.KeySet(["id", "index"]),
+                columns=[
+                    dbscheme.Column('id', '@object'),
+                    dbscheme.Column('index', 'int'),
+                    dbscheme.Column('five', 'v'),
                 ]
             ),
         ],
diff --git a/swift/codegen/test/test_ql.py b/swift/codegen/test/test_ql.py
@@ -59,6 +59,16 @@ def test_property_indefinite_article(name, expected_article):
     assert prop.indefinite_article == expected_article
 
 
+@pytest.mark.parametrize("plural,expected", [
+    (None, False),
+    ("", False),
+    ("X", True),
+])
+def test_property_is_plural(plural, expected):
+    prop = ql.Property("foo", "Foo", "props", ["x"], plural=plural)
+    assert prop.is_repeated is expected
+
+
 def test_property_no_plural_no_indefinite_article():
     prop = ql.Property("Prop", "Foo", "props", ["x"])
     assert prop.indefinite_article is None
diff --git a/swift/codegen/test/test_qlgen.py b/swift/codegen/test/test_qlgen.py
@@ -107,7 +107,8 @@ def test_optional_property(opts, input, renderer):
         import_file(): ql.ImportList([stub_import_prefix + "MyObject"]),
         stub_path() / "MyObject.qll": ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
         ql_output_path() / "MyObject.qll": ql.Class(name="MyObject", final=True, properties=[
-            ql.Property(singular="Foo", type="bar", tablename="my_object_foos", tableparams=["this", "result"]),
+            ql.Property(singular="Foo", type="bar", tablename="my_object_foos", tableparams=["this", "result"],
+                        is_optional=True),
         ])
     }
 
@@ -126,6 +127,20 @@ def test_repeated_property(opts, input, renderer):
     }
 
 
+def test_repeated_optional_property(opts, input, renderer):
+    input.classes = [
+        schema.Class("MyObject", properties=[schema.RepeatedOptionalProperty("foo", "bar")]),
+    ]
+    assert generate(opts, renderer) == {
+        import_file(): ql.ImportList([stub_import_prefix + "MyObject"]),
+        stub_path() / "MyObject.qll": ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
+        ql_output_path() / "MyObject.qll": ql.Class(name="MyObject", final=True, properties=[
+            ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos", params=[index_param],
+                        tableparams=["this", "index", "result"], is_optional=True),
+        ])
+    }
+
+
 def test_single_class_property(opts, input, renderer):
     input.classes = [
         schema.Class("MyObject", properties=[schema.SingleProperty("foo", "Bar")]),
diff --git a/swift/codegen/test/test_schema.py b/swift/codegen/test/test_schema.py
@@ -140,13 +140,15 @@ def test_properties(load):
      one: string
      two: int?
      three: bool*
+     four: x?*
 """)
     assert ret.classes == [
         schema.Class(root_name, derived={'A'}),
         schema.Class('A', bases={root_name}, properties=[
             schema.SingleProperty('one', 'string'),
             schema.OptionalProperty('two', 'int'),
             schema.RepeatedProperty('three', 'bool'),
+            schema.RepeatedOptionalProperty('four', 'x'),
         ]),
     ]
 
diff --git a/swift/ql/lib/codeql/swift/generated/decl/PatternBindingDecl.qll b/swift/ql/lib/codeql/swift/generated/decl/PatternBindingDecl.qll
@@ -15,8 +15,6 @@ class PatternBindingDeclBase extends @pattern_binding_decl, Decl {
 
   Expr getAnInit() { result = getInit(_) }
 
-  int getNumberOfInits() { result = count(getAnInit()) }
-
   Pattern getPattern(int index) {
     exists(Pattern x |
       pattern_binding_decl_patterns(this, index, x) and
