Swift: rename Ipa to Synth

Author: redsun82

swift/codegen/generators/qlgen.py

@@ -91,16 +91,16 @@ def _to_db_type(x: str) -> str:
 
 def get_ql_ipa_class(cls: schema.Class):
     if cls.derived:
-        return ql.Ipa.NonFinalClass(name=cls.name, derived=sorted(cls.derived),
-                                    root=(cls.name == schema.root_class_name))
+        return ql.Synth.NonFinalClass(name=cls.name, derived=sorted(cls.derived),
+                                      root=(cls.name == schema.root_class_name))
     if cls.ipa and cls.ipa.from_class is not None:
         source = cls.ipa.from_class
-        _final_db_class_lookup.setdefault(source, ql.Ipa.FinalClassDb(source)).subtract_type(cls.name)
-        return ql.Ipa.FinalClassDerivedIpa(name=cls.name, params=[ql.Ipa.Param("id", _to_db_type(source))])
+        _final_db_class_lookup.setdefault(source, ql.Synth.FinalClassDb(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.Ipa.FinalClassFreshIpa(name=cls.name, params=[ql.Ipa.Param(k, _to_db_type(v)) for k, v in
-                                                                cls.ipa.on_arguments.items()])
-    return _final_db_class_lookup.setdefault(cls.name, ql.Ipa.FinalClassDb(cls.name))
+        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 _final_db_class_lookup.setdefault(cls.name, ql.Synth.FinalClassDb(cls.name))
 
 
 def get_import(file: pathlib.Path, swift_dir: pathlib.Path):
@@ -275,13 +275,13 @@ def generate(opts, renderer):
             if ipa_type.is_ipa and ipa_type.has_params:
                 stub_file = stub_out / cls.dir / f"{cls.name}Constructor.qll"
                 if not stub_file.is_file() or _is_generated_stub(stub_file):
-                    renderer.render(ql.Ipa.ConstructorStub(ipa_type), stub_file)
+                    renderer.render(ql.Synth.ConstructorStub(ipa_type), stub_file)
                 constructor_imports.append(get_import(stub_file, opts.swift_dir))
         else:
             non_final_ipa_types.append(ipa_type)
 
-    renderer.render(ql.Ipa.Types(schema.root_class_name, final_ipa_types, non_final_ipa_types), out / "Ipa.qll")
-    renderer.render(ql.ImportList(constructor_imports), out / "IpaConstructors.qll")
+    renderer.render(ql.Synth.Types(schema.root_class_name, final_ipa_types, non_final_ipa_types), out / "Synth.qll")
+    renderer.render(ql.ImportList(constructor_imports), out / "SynthConstructors.qll")
 
     renderer.cleanup(existing)
     if opts.ql_format:

swift/codegen/lib/ql.py

@@ -158,7 +158,7 @@ class MissingTestInstructions:
     template: ClassVar = 'ql_test_missing'
 
 
-class Ipa:
+class Synth:
     @dataclass
     class Class:
         is_final: ClassVar = False
@@ -185,7 +185,7 @@ class Param:
 
     @dataclass
     class FinalClassIpa(FinalClass):
-        params: List["Ipa.Param"] = field(default_factory=list)
+        params: List["Synth.Param"] = field(default_factory=list)
 
         def __post_init__(self):
             if self.params:
@@ -207,10 +207,10 @@ class FinalClassFreshIpa(FinalClassIpa):
     class FinalClassDb(FinalClass):
         is_db: ClassVar = True
 
-        subtracted_ipa_types: List["Ipa.Class"] = field(default_factory=list)
+        subtracted_ipa_types: List["Synth.Class"] = field(default_factory=list)
 
         def subtract_type(self, type: str):
-            self.subtracted_ipa_types.append(Ipa.Class(type, first=not self.subtracted_ipa_types))
+            self.subtracted_ipa_types.append(Synth.Class(type, first=not self.subtracted_ipa_types))
 
         @property
         def has_subtracted_ipa_types(self) -> bool:
@@ -222,11 +222,11 @@ def db_id(self) -> str:
 
     @dataclass
     class NonFinalClass(Class):
-        derived: List["Ipa.Class"] = field(default_factory=list)
+        derived: List["Synth.Class"] = field(default_factory=list)
         root: bool = False
 
         def __post_init__(self):
-            self.derived = [Ipa.Class(c) for c in self.derived]
+            self.derived = [Synth.Class(c) for c in self.derived]
             if self.derived:
                 self.derived[0].first = True
 
@@ -235,8 +235,8 @@ class Types:
         template: ClassVar = "ql_ipa_types"
 
         root: str
-        final_classes: List["Ipa.FinalClass"] = field(default_factory=list)
-        non_final_classes: List["Ipa.NonFinalClass"] = field(default_factory=list)
+        final_classes: List["Synth.FinalClass"] = field(default_factory=list)
+        non_final_classes: List["Synth.NonFinalClass"] = field(default_factory=list)
 
         def __post_init__(self):
             if self.final_classes:
@@ -246,4 +246,4 @@ def __post_init__(self):
     class ConstructorStub:
         template: ClassVar = "ql_ipa_constructor_stub"
 
-        cls: Union["Ipa.FinalClassDerivedIpa", "Ipa.FinalClassFreshIpa"]
+        cls: Union["Synth.FinalClassDerivedIpa", "Synth.FinalClassFreshIpa"]

swift/codegen/lib/schema.py

@@ -160,7 +160,7 @@ def load(path):
                 cls.properties.extend(_parse_property(kk, vv, is_child=True) for kk, vv in v.items())
             elif k == "_pragma":
                 cls.pragmas = _auto_list(v)
-            elif k == "_ipa":
+            elif k == "_synth":
                 cls.ipa = _parse_ipa(v)
             else:
                 raise Error(f"unknown metadata {k} for class {name}")

swift/codegen/schema.yml

@@ -26,7 +26,7 @@ DbFile:
 
 UnknownFile:
   _extends: File
-  _ipa:
+  _synth:
     on: {}
 
 Locatable:
@@ -48,7 +48,7 @@ DbLocation:
 
 UnknownLocation:
   _extends: Location
-  _ipa:
+  _synth:
     on: {}
 
 Comment:
@@ -816,7 +816,7 @@ TryExpr:
 
 #MethodCallExpr:
 #  _extends: ApplyExpr
-#  _ipa:
+#  _synth:
 #    from: CallExpr
 #  qualifier: Expr
 

swift/codegen/templates/ql_class.mustache

@@ -1,11 +1,11 @@
 // generated by {{generator}}
-private import codeql.swift.generated.Ipa
+private import codeql.swift.generated.Synth
 private import codeql.swift.generated.Db
 {{#imports}}
 import {{.}}
 {{/imports}}
 
-class {{name}}Base extends Ipa::T{{name}}{{#bases}}, {{.}}{{/bases}} {
+class {{name}}Base extends Synth::T{{name}}{{#bases}}, {{.}}{{/bases}} {
   {{#root}}
   string toString() { none() } // overridden by subclasses
 
@@ -29,7 +29,7 @@ class {{name}}Base extends Ipa::T{{name}}{{#bases}}, {{.}}{{/bases}} {
   {{#type_is_class}}
   {{type}} getImmediate{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
     {{^ipa}}
-    result = Ipa::convert{{type}}FromDb(Ipa::convert{{name}}ToDb(this){{^root}}.(Db::{{name}}){{/root}}.{{getter}}({{#is_repeated}}index{{/is_repeated}}))
+    result = Synth::convert{{type}}FromDb(Synth::convert{{name}}ToDb(this){{^root}}.(Db::{{name}}){{/root}}.{{getter}}({{#is_repeated}}index{{/is_repeated}}))
     {{/ipa}}
     {{#ipa}}
     none()
@@ -44,7 +44,7 @@ class {{name}}Base extends Ipa::T{{name}}{{#bases}}, {{.}}{{/bases}} {
   {{^type_is_class}}
   {{type}} {{getter}}({{#is_repeated}}int index{{/is_repeated}}) {
     {{^ipa}}
-    {{^is_predicate}}result = {{/is_predicate}}Ipa::convert{{name}}ToDb(this){{^root}}.(Db::{{name}}){{/root}}.{{getter}}({{#is_repeated}}index{{/is_repeated}})
+    {{^is_predicate}}result = {{/is_predicate}}Synth::convert{{name}}ToDb(this){{^root}}.(Db::{{name}}){{/root}}.{{getter}}({{#is_repeated}}index{{/is_repeated}})
     {{/ipa}}
     {{#ipa}}
     none()

swift/codegen/templates/ql_ipa_types.mustache

@@ -1,7 +1,7 @@
-private import codeql.swift.generated.IpaConstructors
+private import codeql.swift.generated.SynthConstructors
 private import codeql.swift.generated.Db
 
-cached module Ipa {
+cached module Synth {
   cached newtype T{{root}} =
     {{#final_classes}}
     {{^first}}

swift/codegen/test/test_qlgen.py

@@ -101,7 +101,7 @@ def _filter_generated_classes(ret, output_test_files=False):
             str(f): ret[ql_test_output_path() / f]
             for f in test_files
         }
-    base_files -= {pathlib.Path(f"{name}.qll") for name in ("Db", "Ipa", "IpaConstructors")}
+    base_files -= {pathlib.Path(f"{name}.qll") for name in ("Db", "Synth", "SynthConstructors")}
     assert stub_files == base_files
     return {
         str(f): (ret[stub_path() / f], ret[ql_output_path() / f])
@@ -129,8 +129,8 @@ def test_empty(generate):
     assert generate([]) == {
         import_file(): ql.ImportList(),
         children_file(): ql.GetParentImplementation(),
-        ql_output_path() / "Ipa.qll": ql.Ipa.Types(schema.root_class_name),
-        ql_output_path() / "IpaConstructors.qll": ql.ImportList(),
+        ql_output_path() / "Synth.qll": ql.Synth.Types(schema.root_class_name),
+        ql_output_path() / "SynthConstructors.qll": ql.ImportList(),
         ql_output_path() / "Db.qll": ql.DbClasses(),
         ql_output_path() / "Db.qll": ql.DbClasses(),
     }

swift/codegen/test/test_schema.py

@@ -306,7 +306,7 @@ def test_class_with_unknown_metadata(load):
 def test_ipa_class_from(load):
     ret = load("""
 MyClass:
-    _ipa:
+    _synth:
         from: A
 """)
     assert ret.classes == {
@@ -318,7 +318,7 @@ def test_ipa_class_from(load):
 def test_ipa_class_on(load):
     ret = load("""
 MyClass:
-    _ipa:
+    _synth:
         on: 
             x: A
             y: int
@@ -329,7 +329,7 @@ def test_ipa_class_on(load):
     }
 
 
-# TODO rejection tests and implementation for malformed `_ipa` clauses
+# TODO rejection tests and implementation for malformed `_synth` clauses
 
 
 if __name__ == '__main__':

swift/ql/lib/codeql/swift/controlflow/BasicBlocks.qll

@@ -7,7 +7,7 @@ private import internal.ControlFlowElements
 private import CfgNodes
 private import SuccessorTypes
 private import codeql.swift.generated.Db
-private import codeql.swift.generated.Ipa
+private import codeql.swift.generated.Synth
 
 /**
  * A basic block, that is, a maximal straight-line sequence of control flow nodes
@@ -202,7 +202,7 @@ private module JoinBlockPredecessors {
   private predicate idOfDbAstNode(Db::AstNode x, int y) = equivalenceRelation(id/2)(x, y)
 
   // TODO does not work if fresh ipa entities (`ipa: on:`) turn out to be first of the block
-  private predicate idOf(AstNode x, int y) { idOfDbAstNode(Ipa::convertAstNodeToDb(x), y) }
+  private predicate idOf(AstNode x, int y) { idOfDbAstNode(Synth::convertAstNodeToDb(x), y) }
 
   private AstNode projectToAst(ControlFlowElement n) {
     result = n.asAstNode()

swift/ql/lib/codeql/swift/controlflow/internal/ControlFlowGraphImpl.qll

@@ -33,7 +33,7 @@
 
 private import swift
 private import codeql.swift.controlflow.ControlFlowGraph
-private import codeql.swift.generated.Ipa
+private import codeql.swift.generated.Synth
 private import Completion
 private import Scope
 import ControlFlowGraphImplShared
@@ -380,9 +380,9 @@ module Stmts {
    * Control-flow for loops.
    */
   module Loops {
-    class ConditionalLoop = Ipa::TWhileStmt or Ipa::TRepeatWhileStmt;
+    class ConditionalLoop = Synth::TWhileStmt or Synth::TRepeatWhileStmt;
 
-    class LoopStmt = Ipa::TForEachStmt or ConditionalLoop;
+    class LoopStmt = Synth::TForEachStmt or ConditionalLoop;
 
     abstract class LoopTree extends AstPreOrderTree {
       LoopTree() { ast instanceof ConditionalLoop }
@@ -1708,7 +1708,7 @@ module Exprs {
 
   module Conversions {
     class ConversionOrIdentity =
-      Ipa::TIdentityExpr or Ipa::TExplicitCastExpr or Ipa::TImplicitConversionExpr;
+      Synth::TIdentityExpr or Synth::TExplicitCastExpr or Synth::TImplicitConversionExpr;
 
     abstract class ConversionOrIdentityTree extends AstStandardPostOrderTree {
       ConversionOrIdentityTree() { ast instanceof ConversionOrIdentity }