Codegen: rename ipa to synth

Author: redsun82

misc/codegen/generators/cppgen.py

@@ -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,10 +40,10 @@ 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

misc/codegen/generators/qlgen.py

@@ -111,7 +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.ipa) or prop.synth,
+        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:
@@ -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 name, cls in classes.items() if not data.classes[name].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

@@ -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

@@ -75,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
 
@@ -88,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
@@ -105,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

@@ -160,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()}))

misc/codegen/loaders/schemaloader.py

@@ -40,7 +40,7 @@ def _get_class(cls: type) -> schema.Class:
                         hideable=getattr(cls, "_hideable", False),
                         # in the following we don't use `getattr` to avoid inheriting
                         pragmas=cls.__dict__.get("_pragmas", []),
-                        ipa=cls.__dict__.get("_ipa", None),
+                        synth=cls.__dict__.get("_synth", None),
                         properties=[
                             a | _PropertyNamer(n)
                             for n, a in cls.__dict__.get("__annotations__", {}).items()
@@ -65,34 +65,34 @@ def _toposort_classes_by_group(classes: typing.Dict[str, schema.Class]) -> typin
     return ret
 
 
-def _fill_ipa_information(classes: typing.Dict[str, schema.Class]):
-    """ Take a dictionary where the `ipa` field is filled for all explicitly synthesized classes
+def _fill_synth_information(classes: typing.Dict[str, schema.Class]):
+    """ Take a dictionary where the `synth` field is filled for all explicitly synthesized classes
     and update it so that all non-final classes that have only synthesized final descendants
-    get `True` as` value for the `ipa` field
+    get `True` as` value for the `synth` field
     """
     if not classes:
         return
 
-    is_ipa: typing.Dict[str, bool] = {}
+    is_synth: typing.Dict[str, bool] = {}
 
-    def fill_is_ipa(name: str):
-        if name not in is_ipa:
+    def fill_is_synth(name: str):
+        if name not in is_synth:
             cls = classes[name]
             for d in cls.derived:
-                fill_is_ipa(d)
-            if cls.ipa is not None:
-                is_ipa[name] = True
+                fill_is_synth(d)
+            if cls.synth is not None:
+                is_synth[name] = True
             elif not cls.derived:
-                is_ipa[name] = False
+                is_synth[name] = False
             else:
-                is_ipa[name] = all(is_ipa[d] for d in cls.derived)
+                is_synth[name] = all(is_synth[d] for d in cls.derived)
 
     root = next(iter(classes))
-    fill_is_ipa(root)
+    fill_is_synth(root)
 
     for name, cls in classes.items():
-        if cls.ipa is None and is_ipa[name]:
-            cls.ipa = True
+        if cls.synth is None and is_synth[name]:
+            cls.synth = True
 
 
 def _fill_hideable_information(classes: typing.Dict[str, schema.Class]):
@@ -134,7 +134,7 @@ def load(m: types.ModuleType) -> schema.Schema:
             null = name
             cls.is_null_class = True
 
-    _fill_ipa_information(classes)
+    _fill_synth_information(classes)
     _fill_hideable_information(classes)
 
     return schema.Schema(includes=includes, classes=_toposort_classes_by_group(classes), null=null)

misc/codegen/templates/ql_stub.mustache

@@ -1,18 +1,18 @@
 // generated by {{generator}}, remove this comment if you wish to edit this file
 private import {{base_import}}
-{{#has_ipa_accessors}}
+{{#has_synth_accessors}}
 private import {{import_prefix}}.Raw
 private import {{import_prefix}}.Synth
-{{/has_ipa_accessors}}
+{{/has_synth_accessors}}
 
 {{#ql_internal}}
 /**
  * INTERNAL: Do not use.
  */
 {{/ql_internal}}
 class {{name}} extends Generated::{{name}} {
-    {{#ipa_accessors}}
+    {{#synth_accessors}}
     private
     cached {{type}} getUnderlying{{argument}}() { this = Synth::T{{name}}({{#constructorparams}}{{^first}},{{/first}}{{param}}{{/constructorparams}})}
-    {{/ipa_accessors}}
+    {{/synth_accessors}}
 }