Merge pull request #13258 from github/redsun82/swift-synth-properties

Codegen: allow `synth` properties of non-`synth` classes

Author: redsun82

misc/codegen/generators/cppgen.py

@@ -76,7 +76,7 @@ def _get_class(self, name: str) -> cpp.Class:
             bases=[self._get_class(b) for b in cls.bases],
             fields=[
                 _get_field(cls, p, self._add_or_none_except)
-                for p in cls.properties if "cpp_skip" not in p.pragmas
+                for p in cls.properties if "cpp_skip" not in p.pragmas and not p.synth
             ],
             final=not cls.derived,
             trap_name=trap_name,
@@ -85,7 +85,7 @@ def _get_class(self, name: str) -> cpp.Class:
     def get_classes(self):
         ret = {'': []}
         for k, cls in self._classmap.items():
-            if not cls.ipa:
+            if not cls.synth:
                 ret.setdefault(cls.group, []).append(self._get_class(cls.name))
         return ret
 

misc/codegen/generators/dbschemegen.py

@@ -40,16 +40,16 @@ def dbtype(typename: str, add_or_none_except: typing.Optional[str] = None) -> st
 
 def cls_to_dbscheme(cls: schema.Class, lookup: typing.Dict[str, schema.Class], add_or_none_except: typing.Optional[str] = None):
     """ Yield all dbscheme entities needed to model class `cls` """
-    if cls.ipa:
+    if cls.synth:
         return
     if cls.derived:
-        yield Union(dbtype(cls.name), (dbtype(c) for c in cls.derived if not lookup[c].ipa))
+        yield Union(dbtype(cls.name), (dbtype(c) for c in cls.derived if not lookup[c].synth))
     dir = pathlib.Path(cls.group) if cls.group else None
     # output a table specific to a class only if it is a leaf class or it has 1-to-1 properties
     # Leaf classes need a table to bind the `@` ids
     # 1-to-1 properties are added to a class specific table
     # in other cases, separate tables are used for the properties, and a class specific table is unneeded
-    if not cls.derived or any(f.is_single for f in cls.properties):
+    if not cls.derived or any(f.is_single and not f.synth for f in cls.properties):
         binding = not cls.derived
         keyset = KeySet(["id"]) if cls.derived else None
         yield Table(
@@ -58,12 +58,15 @@ def cls_to_dbscheme(cls: schema.Class, lookup: typing.Dict[str, schema.Class], a
             columns=[
                 Column("id", type=dbtype(cls.name), binding=binding),
             ] + [
-                Column(f.name, dbtype(f.type, add_or_none_except)) for f in cls.properties if f.is_single
+                Column(f.name, dbtype(f.type, add_or_none_except))
+                for f in cls.properties if f.is_single and not f.synth
             ],
             dir=dir,
         )
     # use property-specific tables for 1-to-many and 1-to-at-most-1 properties
     for f in cls.properties:
+        if f.synth:
+            continue
         if f.is_unordered:
             yield Table(
                 name=inflection.tableize(f"{cls.name}_{f.name}"),

misc/codegen/generators/qlgen.py

@@ -111,6 +111,7 @@ def get_ql_property(cls: schema.Class, prop: schema.Property, lookup: typing.Dic
         is_predicate=prop.is_predicate,
         is_unordered=prop.is_unordered,
         description=prop.description,
+        synth=bool(cls.synth) or prop.synth,
         type_is_hideable=lookup[prop.type].hideable if prop.type in lookup else False,
     )
     if prop.is_single:
@@ -163,7 +164,6 @@ def get_ql_class(cls: schema.Class, lookup: typing.Dict[str, schema.Class]) -> q
         final=not cls.derived,
         properties=properties,
         dir=pathlib.Path(cls.group or ""),
-        ipa=bool(cls.ipa),
         doc=cls.doc,
         hideable=cls.hideable,
         **pragmas,
@@ -179,26 +179,26 @@ def _to_db_type(x: str) -> str:
 _final_db_class_lookup = {}
 
 
-def get_ql_ipa_class_db(name: str) -> ql.Synth.FinalClassDb:
+def get_ql_synth_class_db(name: str) -> ql.Synth.FinalClassDb:
     return _final_db_class_lookup.setdefault(name, ql.Synth.FinalClassDb(name=name,
                                                                          params=[
                                                                              ql.Synth.Param("id", _to_db_type(name))]))
 
 
-def get_ql_ipa_class(cls: schema.Class):
+def get_ql_synth_class(cls: schema.Class):
     if cls.derived:
         return ql.Synth.NonFinalClass(name=cls.name, derived=sorted(cls.derived),
                                       root=not cls.bases)
-    if cls.ipa and cls.ipa.from_class is not None:
-        source = cls.ipa.from_class
-        get_ql_ipa_class_db(source).subtract_type(cls.name)
-        return ql.Synth.FinalClassDerivedIpa(name=cls.name,
-                                             params=[ql.Synth.Param("id", _to_db_type(source))])
-    if cls.ipa and cls.ipa.on_arguments is not None:
-        return ql.Synth.FinalClassFreshIpa(name=cls.name,
-                                           params=[ql.Synth.Param(k, _to_db_type(v))
-                                                   for k, v in cls.ipa.on_arguments.items()])
-    return get_ql_ipa_class_db(cls.name)
+    if cls.synth and cls.synth.from_class is not None:
+        source = cls.synth.from_class
+        get_ql_synth_class_db(source).subtract_type(cls.name)
+        return ql.Synth.FinalClassDerivedSynth(name=cls.name,
+                                               params=[ql.Synth.Param("id", _to_db_type(source))])
+    if cls.synth and cls.synth.on_arguments is not None:
+        return ql.Synth.FinalClassFreshSynth(name=cls.name,
+                                             params=[ql.Synth.Param(k, _to_db_type(v))
+                                                     for k, v in cls.synth.on_arguments.items()])
+    return get_ql_synth_class_db(cls.name)
 
 
 def get_import(file: pathlib.Path, root_dir: pathlib.Path):
@@ -291,26 +291,26 @@ def _should_skip_qltest(cls: schema.Class, lookup: typing.Dict[str, schema.Class
 
 
 def _get_stub(cls: schema.Class, base_import: str, generated_import_prefix: str) -> ql.Stub:
-    if isinstance(cls.ipa, schema.IpaInfo):
-        if cls.ipa.from_class is not None:
+    if isinstance(cls.synth, schema.SynthInfo):
+        if cls.synth.from_class is not None:
             accessors = [
-                ql.IpaUnderlyingAccessor(
+                ql.SynthUnderlyingAccessor(
                     argument="Entity",
-                    type=_to_db_type(cls.ipa.from_class),
+                    type=_to_db_type(cls.synth.from_class),
                     constructorparams=["result"]
                 )
             ]
-        elif cls.ipa.on_arguments is not None:
+        elif cls.synth.on_arguments is not None:
             accessors = [
-                ql.IpaUnderlyingAccessor(
+                ql.SynthUnderlyingAccessor(
                     argument=inflection.camelize(arg),
                     type=_to_db_type(type),
-                    constructorparams=["result" if a == arg else "_" for a in cls.ipa.on_arguments]
-                ) for arg, type in cls.ipa.on_arguments.items()
+                    constructorparams=["result" if a == arg else "_" for a in cls.synth.on_arguments]
+                ) for arg, type in cls.synth.on_arguments.items()
             ]
     else:
         accessors = []
-    return ql.Stub(name=cls.name, base_import=base_import, import_prefix=generated_import_prefix, ipa_accessors=accessors)
+    return ql.Stub(name=cls.name, base_import=base_import, import_prefix=generated_import_prefix, synth_accessors=accessors)
 
 
 def generate(opts, renderer):
@@ -344,7 +344,7 @@ def generate(opts, renderer):
     with renderer.manage(generated=generated, stubs=stubs, registry=opts.generated_registry,
                          force=opts.force) as renderer:
 
-        db_classes = [cls for cls in classes.values() if not cls.ipa]
+        db_classes = [cls for name, cls in classes.items() if not data.classes[name].synth]
         renderer.render(ql.DbClasses(db_classes), out / "Raw.qll")
 
         classes_by_dir_and_name = sorted(classes.values(), key=lambda cls: (cls.dir, cls.name))
@@ -401,32 +401,32 @@ def generate(opts, renderer):
                                                       elements_module=elements_module,
                                                       property=p), test_dir / f"{c.name}_{p.getter}.ql")
 
-        final_ipa_types = []
-        non_final_ipa_types = []
+        final_synth_types = []
+        non_final_synth_types = []
         constructor_imports = []
-        ipa_constructor_imports = []
+        synth_constructor_imports = []
         stubs = {}
         for cls in sorted(data.classes.values(), key=lambda cls: (cls.group, cls.name)):
-            ipa_type = get_ql_ipa_class(cls)
-            if ipa_type.is_final:
-                final_ipa_types.append(ipa_type)
-                if ipa_type.has_params:
+            synth_type = get_ql_synth_class(cls)
+            if synth_type.is_final:
+                final_synth_types.append(synth_type)
+                if synth_type.has_params:
                     stub_file = stub_out / cls.group / f"{cls.name}Constructor.qll"
                     if not renderer.is_customized_stub(stub_file):
-                        # stub rendering must be postponed as we might not have yet all subtracted ipa types in `ipa_type`
-                        stubs[stub_file] = ql.Synth.ConstructorStub(ipa_type, import_prefix=generated_import_prefix)
+                        # stub rendering must be postponed as we might not have yet all subtracted synth types in `synth_type`
+                        stubs[stub_file] = ql.Synth.ConstructorStub(synth_type, import_prefix=generated_import_prefix)
                     constructor_import = get_import(stub_file, opts.root_dir)
                     constructor_imports.append(constructor_import)
-                    if ipa_type.is_ipa:
-                        ipa_constructor_imports.append(constructor_import)
+                    if synth_type.is_synth:
+                        synth_constructor_imports.append(constructor_import)
             else:
-                non_final_ipa_types.append(ipa_type)
+                non_final_synth_types.append(synth_type)
 
         for stub_file, data in stubs.items():
             renderer.render(data, stub_file)
         renderer.render(ql.Synth.Types(root.name, generated_import_prefix,
-                        final_ipa_types, non_final_ipa_types), out / "Synth.qll")
+                        final_synth_types, non_final_synth_types), out / "Synth.qll")
         renderer.render(ql.ImportList(constructor_imports), out / "SynthConstructors.qll")
-        renderer.render(ql.ImportList(ipa_constructor_imports), out / "PureSynthConstructors.qll")
+        renderer.render(ql.ImportList(synth_constructor_imports), out / "PureSynthConstructors.qll")
         if opts.ql_format:
             format(opts.codeql_binary, renderer.written)

misc/codegen/lib/ql.py

@@ -42,6 +42,7 @@ class Property:
     description: List[str] = field(default_factory=list)
     doc: Optional[str] = None
     doc_plural: Optional[str] = None
+    synth: bool = False
     type_is_hideable: bool = False
 
     def __post_init__(self):
@@ -112,7 +113,6 @@ class Class:
     qltest_collapse_hierarchy: bool = False
     qltest_uncollapse_hierarchy: bool = False
     ql_internal: bool = False
-    ipa: bool = False
     doc: List[str] = field(default_factory=list)
     hideable: bool = False
 
@@ -147,7 +147,7 @@ def has_doc(self) -> bool:
 
 
 @dataclass
-class IpaUnderlyingAccessor:
+class SynthUnderlyingAccessor:
     argument: str
     type: str
     constructorparams: List[Param]
@@ -165,11 +165,11 @@ class Stub:
     name: str
     base_import: str
     import_prefix: str
-    ipa_accessors: List[IpaUnderlyingAccessor] = field(default_factory=list)
+    synth_accessors: List[SynthUnderlyingAccessor] = field(default_factory=list)
 
     @property
-    def has_ipa_accessors(self) -> bool:
-        return bool(self.ipa_accessors)
+    def has_synth_accessors(self) -> bool:
+        return bool(self.synth_accessors)
 
 
 @dataclass
@@ -245,8 +245,8 @@ class Param:
     @dataclass
     class FinalClass(Class):
         is_final: ClassVar = True
-        is_derived_ipa: ClassVar = False
-        is_fresh_ipa: ClassVar = False
+        is_derived_synth: ClassVar = False
+        is_fresh_synth: ClassVar = False
         is_db: ClassVar = False
 
         params: List["Synth.Param"] = field(default_factory=list)
@@ -256,37 +256,37 @@ def __post_init__(self):
                 self.params[0].first = True
 
         @property
-        def is_ipa(self):
-            return self.is_fresh_ipa or self.is_derived_ipa
+        def is_synth(self):
+            return self.is_fresh_synth or self.is_derived_synth
 
         @property
         def has_params(self) -> bool:
             return bool(self.params)
 
     @dataclass
-    class FinalClassIpa(FinalClass):
+    class FinalClassSynth(FinalClass):
         pass
 
     @dataclass
-    class FinalClassDerivedIpa(FinalClassIpa):
-        is_derived_ipa: ClassVar = True
+    class FinalClassDerivedSynth(FinalClassSynth):
+        is_derived_synth: ClassVar = True
 
     @dataclass
-    class FinalClassFreshIpa(FinalClassIpa):
-        is_fresh_ipa: ClassVar = True
+    class FinalClassFreshSynth(FinalClassSynth):
+        is_fresh_synth: ClassVar = True
 
     @dataclass
     class FinalClassDb(FinalClass):
         is_db: ClassVar = True
 
-        subtracted_ipa_types: List["Synth.Class"] = field(default_factory=list)
+        subtracted_synth_types: List["Synth.Class"] = field(default_factory=list)
 
         def subtract_type(self, type: str):
-            self.subtracted_ipa_types.append(Synth.Class(type, first=not self.subtracted_ipa_types))
+            self.subtracted_synth_types.append(Synth.Class(type, first=not self.subtracted_synth_types))
 
         @property
-        def has_subtracted_ipa_types(self) -> bool:
-            return bool(self.subtracted_ipa_types)
+        def has_subtracted_synth_types(self) -> bool:
+            return bool(self.subtracted_synth_types)
 
         @property
         def db_id(self) -> str:
@@ -304,7 +304,7 @@ def __post_init__(self):
 
     @dataclass
     class Types:
-        template: ClassVar = "ql_ipa_types"
+        template: ClassVar = "ql_synth_types"
 
         root: str
         import_prefix: str
@@ -317,7 +317,7 @@ def __post_init__(self):
 
     @dataclass
     class ConstructorStub:
-        template: ClassVar = "ql_ipa_constructor_stub"
+        template: ClassVar = "ql_synth_constructor_stub"
 
         cls: "Synth.FinalClass"
         import_prefix: str

misc/codegen/lib/schema.py

@@ -34,6 +34,7 @@ class Kind(Enum):
     pragmas: List[str] = field(default_factory=list)
     doc: Optional[str] = None
     description: List[str] = field(default_factory=list)
+    synth: bool = False
 
     @property
     def is_single(self) -> bool:
@@ -74,7 +75,7 @@ def has_builtin_type(self) -> bool:
 
 
 @dataclass
-class IpaInfo:
+class SynthInfo:
     from_class: Optional[str] = None
     on_arguments: Optional[Dict[str, str]] = None
 
@@ -87,7 +88,7 @@ class Class:
     properties: List[Property] = field(default_factory=list)
     group: str = ""
     pragmas: List[str] = field(default_factory=list)
-    ipa: Optional[Union[IpaInfo, bool]] = None
+    synth: Optional[Union[SynthInfo, bool]] = None
     """^^^ filled with `True` for non-final classes with only synthesized final descendants """
     doc: List[str] = field(default_factory=list)
     default_doc_name: Optional[str] = None
@@ -104,10 +105,10 @@ def check_types(self, known: typing.Iterable[str]):
             _check_type(d, known)
         for p in self.properties:
             _check_type(p.type, known)
-        if self.ipa is not None:
-            _check_type(self.ipa.from_class, known)
-            if self.ipa.on_arguments is not None:
-                for t in self.ipa.on_arguments.values():
+        if self.synth is not None:
+            _check_type(self.synth.from_class, known)
+            if self.synth.on_arguments is not None:
+                for t in self.synth.on_arguments.values():
                     _check_type(t, known)
 
 

misc/codegen/lib/schemadefs.py

@@ -44,10 +44,15 @@ def __init__(self, **kwargs):
         self.__dict__.update(kwargs)
 
 
+class _SynthModifier(_schema.PropertyModifier, _Namespace):
+    def modify(self, prop: _schema.Property):
+        prop.synth = True
+
+
 qltest = _Namespace()
 ql = _Namespace()
 cpp = _Namespace()
-synth = _Namespace()
+synth = _SynthModifier()
 
 
 @_dataclass
@@ -155,7 +160,7 @@ def group(name: str = "") -> _ClassDecorator:
     return _annotate(group=name)
 
 
-synth.from_class = lambda ref: _annotate(ipa=_schema.IpaInfo(
+synth.from_class = lambda ref: _annotate(synth=_schema.SynthInfo(
     from_class=_schema.get_type_name(ref)))
 synth.on_arguments = lambda **kwargs: _annotate(
-    ipa=_schema.IpaInfo(on_arguments={k: _schema.get_type_name(t) for k, t in kwargs.items()}))
+    synth=_schema.SynthInfo(on_arguments={k: _schema.get_type_name(t) for k, t in kwargs.items()}))