Merge pull request github#12710 from github/redsun82/swift-imported-modules-as-set

Swift: make imported and exported modules a set

Author: redsun82

.pre-commit-config.yaml

@@ -19,7 +19,7 @@ repos:
     rev: v1.6.0
     hooks:
       - id: autopep8
-        files: ^swift/.*\.py
+        files: ^misc/codegen/.*\.py
 
   - repo: local
     hooks:

misc/codegen/generators/cppgen.py

@@ -49,6 +49,7 @@ def _get_field(cls: schema.Class, p: schema.Property, add_or_none_except: typing
         is_optional=p.is_optional,
         is_repeated=p.is_repeated,
         is_predicate=p.is_predicate,
+        is_unordered=p.is_unordered,
         trap_name=trap_name,
     )
     args.update(cpp.get_field_override(p.name))

misc/codegen/generators/dbschemegen.py

@@ -64,7 +64,16 @@ def cls_to_dbscheme(cls: schema.Class, lookup: typing.Dict[str, schema.Class], a
         )
     # use property-specific tables for 1-to-many and 1-to-at-most-1 properties
     for f in cls.properties:
-        if f.is_repeated:
+        if f.is_unordered:
+            yield Table(
+                name=inflection.tableize(f"{cls.name}_{f.name}"),
+                columns=[
+                    Column("id", type=dbtype(cls.name)),
+                    Column(inflection.singularize(f.name), dbtype(f.type, add_or_none_except)),
+                ],
+                dir=dir,
+            )
+        elif f.is_repeated:
             yield Table(
                 keyset=KeySet(["id", "index"]),
                 name=inflection.tableize(f"{cls.name}_{f.name}"),

misc/codegen/generators/qlgen.py

@@ -109,6 +109,7 @@ def get_ql_property(cls: schema.Class, prop: schema.Property, prev_child: str =
         prev_child=prev_child if prop.is_child else None,
         is_optional=prop.is_optional,
         is_predicate=prop.is_predicate,
+        is_unordered=prop.is_unordered,
         description=prop.description
     )
     if prop.is_single:
@@ -123,7 +124,7 @@ def get_ql_property(cls: schema.Class, prop: schema.Property, prev_child: str =
             singular=inflection.singularize(inflection.camelize(prop.name)),
             plural=inflection.pluralize(inflection.camelize(prop.name)),
             tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
-            tableparams=["this", "index", "result"],
+            tableparams=["this", "index", "result"] if not prop.is_unordered else ["this", "result"],
             doc=_get_doc(cls, prop, plural=False),
             doc_plural=_get_doc(cls, prop, plural=True),
         )
@@ -255,7 +256,7 @@ def _get_all_properties_to_be_tested(cls: schema.Class, lookup: typing.Dict[str,
             # TODO here operations are duplicated, but should be better if we split ql and qltest generation
             p = get_ql_property(c, p)
             yield ql.PropertyForTest(p.getter, is_total=p.is_single or p.is_predicate,
-                                     type=p.type if not p.is_predicate else None, is_repeated=p.is_repeated)
+                                     type=p.type if not p.is_predicate else None, is_indexed=p.is_indexed)
             if p.is_repeated and not p.is_optional:
                 yield ql.PropertyForTest(f"getNumberOf{p.plural}", type="int")
             elif p.is_optional and not p.is_repeated:

misc/codegen/lib/cpp.py

@@ -36,6 +36,7 @@ class Field:
     base_type: str
     is_optional: bool = False
     is_repeated: bool = False
+    is_unordered: bool = False
     is_predicate: bool = False
     trap_name: str = None
     first: bool = False

misc/codegen/lib/ql.py

@@ -36,6 +36,7 @@ class Property:
     first: bool = False
     is_optional: bool = False
     is_predicate: bool = False
+    is_unordered: bool = False
     prev_child: Optional[str] = None
     qltest_skip: bool = False
     description: List[str] = field(default_factory=list)
@@ -49,7 +50,11 @@ def __post_init__(self):
 
     @property
     def getter(self):
-        return f"get{self.singular}" if not self.is_predicate else self.singular
+        if self.is_predicate:
+            return self.singular
+        if self.is_unordered:
+            return self.indefinite_getter
+        return f"get{self.singular}"
 
     @property
     def indefinite_getter(self):
@@ -77,6 +82,10 @@ def is_child(self):
     def has_description(self) -> bool:
         return bool(self.description)
 
+    @property
+    def is_indexed(self) -> bool:
+        return self.is_repeated and not self.is_unordered
+
 
 @dataclass
 class Base:
@@ -188,7 +197,7 @@ class PropertyForTest:
     getter: str
     is_total: bool = True
     type: Optional[str] = None
-    is_repeated: bool = False
+    is_indexed: bool = False
 
 
 @dataclass

misc/codegen/lib/schema.py

@@ -25,6 +25,7 @@ class Kind(Enum):
         OPTIONAL = auto()
         REPEATED_OPTIONAL = auto()
         PREDICATE = auto()
+        REPEATED_UNORDERED = auto()
 
     kind: Kind
     name: Optional[str] = None
@@ -44,7 +45,11 @@ def is_optional(self) -> bool:
 
     @property
     def is_repeated(self) -> bool:
-        return self.kind in (self.Kind.REPEATED, self.Kind.REPEATED_OPTIONAL)
+        return self.kind in (self.Kind.REPEATED, self.Kind.REPEATED_OPTIONAL, self.Kind.REPEATED_UNORDERED)
+
+    @property
+    def is_unordered(self) -> bool:
+        return self.kind == self.Kind.REPEATED_UNORDERED
 
     @property
     def is_predicate(self) -> bool:
@@ -65,6 +70,7 @@ def has_builtin_type(self) -> bool:
 RepeatedOptionalProperty = functools.partial(
     Property, Property.Kind.REPEATED_OPTIONAL)
 PredicateProperty = functools.partial(Property, Property.Kind.PREDICATE)
+RepeatedUnorderedProperty = functools.partial(Property, Property.Kind.REPEATED_UNORDERED)
 
 
 @dataclass

misc/codegen/lib/schemadefs.py

@@ -8,6 +8,8 @@ class _ChildModifier(_schema.PropertyModifier):
     def modify(self, prop: _schema.Property):
         if prop.type is None or prop.type[0].islower():
             raise _schema.Error("Non-class properties cannot be children")
+        if prop.is_unordered:
+            raise _schema.Error("Set properties cannot be children")
         prop.is_child = True
 
 
@@ -77,7 +79,7 @@ def modify(self, prop: _schema.Property):
         K = _schema.Property.Kind
         if prop.kind != K.SINGLE:
             raise _schema.Error(
-                "Optional should only be applied to simple property types")
+                "optional should only be applied to simple property types")
         prop.kind = K.OPTIONAL
 
 
@@ -90,7 +92,15 @@ def modify(self, prop: _schema.Property):
             prop.kind = K.REPEATED_OPTIONAL
         else:
             raise _schema.Error(
-                "Repeated should only be applied to simple or optional property types")
+                "list should only be applied to simple or optional property types")
+
+
+class _Setifier(_schema.PropertyModifier):
+    def modify(self, prop: _schema.Property):
+        K = _schema.Property.Kind
+        if prop.kind != K.SINGLE:
+            raise _schema.Error("set should only be applied to simple property types")
+        prop.kind = K.REPEATED_UNORDERED
 
 
 class _TypeModifier:
@@ -122,6 +132,7 @@ def f(cls: type) -> type:
 predicate = _schema.predicate_marker
 optional = _TypeModifier(_Optionalizer())
 list = _TypeModifier(_Listifier())
+set = _TypeModifier(_Setifier())
 
 child = _ChildModifier()
 doc = _DocModifier

misc/codegen/schemadefs.py

@@ -24,7 +24,7 @@ void {{name}}::emit({{^final}}TrapLabel<{{name}}Tag> id, {{/final}}std::ostream&
   {{#is_repeated}}
   for (auto i = 0u; i < {{field_name}}.size(); ++i) {
     {{^is_optional}}
-    out << {{trap_name}}Trap{id, i, {{field_name}}[i]} << '\n';
+    out << {{trap_name}}Trap{id, {{^is_unordered}}i, {{/is_unordered}}{{field_name}}[i]} << '\n';
     {{/is_optional}}
     {{#is_optional}}
     if ({{field_name}}[i]) out << {{trap_name}}Trap{id, i, *{{field_name}}[i]} << '\n';