Swift: use IPA layer in generated classes

2025-12-17 01:03:14 +01:00 · 2022-07-20 16:59:12 +02:00
parent ea0725525b
commit 10976bbbab
326 changed files with 5559 additions and 2438 deletions
--- a/swift/codegen/generators/cppgen.py
+++ b/swift/codegen/generators/cppgen.py
@@ -83,7 +83,7 @@ class Processor:

 def generate(opts, renderer):
    assert opts.cpp_output
-    processor = Processor({cls.name: cls for cls in schema.load(opts.schema).classes})
+    processor = Processor(schema.load(opts.schema).classes)
    out = opts.cpp_output
    for dir, classes in processor.get_classes().items():
        include_parent = (dir != pathlib.Path())
--- a/swift/codegen/generators/dbschemegen.py
+++ b/swift/codegen/generators/dbschemegen.py
@@ -88,7 +88,7 @@ def cls_to_dbscheme(cls: schema.Class):


 def get_declarations(data: schema.Schema):
-    return [d for cls in data.classes for d in cls_to_dbscheme(cls)]
+    return [d for cls in data.classes.values() for d in cls_to_dbscheme(cls)]


 def get_includes(data: schema.Schema, include_dir: pathlib.Path, swift_dir: pathlib.Path):
--- a/swift/codegen/generators/qlgen.py
+++ b/swift/codegen/generators/qlgen.py
@@ -1,4 +1,5 @@
 #!/usr/bin/env python3
+# TODO this should probably be split in different generators now: ql, qltest, maybe qlipa

 import logging
 import pathlib
@@ -8,6 +9,7 @@ import typing
 import itertools

 import inflection
+from toposort import toposort_flatten

 from swift.codegen.lib import schema, ql

@@ -27,8 +29,8 @@ class ModifiedStubMarkedAsGeneratedError(Error):
    pass


-def get_ql_property(cls: schema.Class, prop: schema.Property):
-    common_args = dict(
+def get_ql_property(cls: schema.Class, source: schema.Class, prop: schema.Property) -> ql.Property:
+    args = dict(
        type=prop.type if not prop.is_predicate else "predicate",
        qltest_skip="qltest_skip" in prop.pragmas,
        is_child=prop.is_child,
@@ -36,46 +38,46 @@ def get_ql_property(cls: schema.Class, prop: schema.Property):
        is_predicate=prop.is_predicate,
    )
    if prop.is_single:
-        return ql.Property(
-            **common_args,
+        args.update(
            singular=inflection.camelize(prop.name),
-            tablename=inflection.tableize(cls.name),
-            tableparams=[
-                "this"] + ["result" if p is prop else "_" for p in cls.properties if p.is_single],
+            tablename=inflection.tableize(source.name),
+            tableparams=["this"] + ["result" if p is prop else "_" for p in source.properties if p.is_single],
        )
    elif prop.is_repeated:
-        return ql.Property(
-            **common_args,
+        args.update(
            singular=inflection.singularize(inflection.camelize(prop.name)),
            plural=inflection.pluralize(inflection.camelize(prop.name)),
-            tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
+            tablename=inflection.tableize(f"{source.name}_{prop.name}"),
            tableparams=["this", "index", "result"],
        )
    elif prop.is_optional:
-        return ql.Property(
-            **common_args,
+        args.update(
            singular=inflection.camelize(prop.name),
-            tablename=inflection.tableize(f"{cls.name}_{prop.name}"),
+            tablename=inflection.tableize(f"{source.name}_{prop.name}"),
            tableparams=["this", "result"],
        )
    elif prop.is_predicate:
-        return ql.Property(
-            **common_args,
-            singular=inflection.camelize(
-                prop.name, uppercase_first_letter=False),
-            tablename=inflection.underscore(f"{cls.name}_{prop.name}"),
+        args.update(
+            singular=inflection.camelize(prop.name, uppercase_first_letter=False),
+            tablename=inflection.underscore(f"{source.name}_{prop.name}"),
            tableparams=["this"],
        )
+    else:
+        raise ValueError(f"unknown property kind for {prop.name} from {source.name}")
+    return ql.Property(**args)


-def get_ql_class(cls: schema.Class):
+def get_ql_class(cls: schema.Class, lookup: typing.Dict[str, schema.Class]):
    pragmas = {k: True for k in cls.pragmas if k.startswith("ql")}
    return ql.Class(
        name=cls.name,
        bases=cls.bases,
        final=not cls.derived,
-        properties=[get_ql_property(cls, p) for p in cls.properties],
+
+        properties=[get_ql_property(cls, cls, p) for p in cls.properties],
        dir=cls.dir,
+        has_db_id=not cls.ipa or cls.ipa.from_class,
+        ipa=bool(cls.ipa),
        **pragmas,
    )

@@ -92,11 +94,11 @@ _final_db_class_lookup = {}
 def get_ql_ipa_class(cls: schema.Class):
    if cls.derived:
        return ql.Ipa.NonFinalClass(name=cls.name, derived=sorted(cls.derived))
-    if cls.ipa and cls.ipa.from_class:
+    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.FinalClassIpaFrom(name=cls.name, type=_to_db_type(source))
-    if cls.ipa and cls.ipa.on_arguments:
+    if cls.ipa and cls.ipa.on_arguments is not None:
        return ql.Ipa.FinalClassIpaOn(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))
@@ -136,7 +138,6 @@ def _is_generated_stub(file):
        line_threshold = 5
        first_lines = list(itertools.islice(contents, line_threshold))
        if len(first_lines) == line_threshold or not _generated_stub_re.match("".join(first_lines)):
-            print("".join(first_lines))
            raise ModifiedStubMarkedAsGeneratedError(
                f"{file.name} stub was modified but is still marked as generated")
        return True
@@ -154,23 +155,28 @@ def format(codeql, files):
        log.debug(line.strip())


-def _get_all_properties(cls: ql.Class, lookup: typing.Dict[str, ql.Class]) -> typing.Iterable[
-        typing.Tuple[ql.Class, ql.Property]]:
-    for b in cls.bases:
+def _get_all_properties(cls: schema.Class, lookup: typing.Dict[str, schema.Class],
+                        already_seen: typing.Optional[typing.Set[int]] = None) -> \
+        typing.Iterable[typing.Tuple[schema.Class, schema.Property]]:
+    # deduplicate using ids
+    if already_seen is None:
+        already_seen = set()
+    for b in sorted(cls.bases):
        base = lookup[b]
-        for item in _get_all_properties(base, lookup):
+        for item in _get_all_properties(base, lookup, already_seen):
            yield item
    for p in cls.properties:
-        yield cls, p
-
-
-def _get_all_properties_to_be_tested(cls: ql.Class, lookup: typing.Dict[str, ql.Class]) -> typing.Iterable[
-        ql.PropertyForTest]:
-    # deduplicate using id
-    already_seen = set()
-    for c, p in _get_all_properties(cls, lookup):
-        if not (c.qltest_skip or p.qltest_skip or id(p) in already_seen):
+        if id(p) not in already_seen:
            already_seen.add(id(p))
+            yield cls, p
+
+
+def _get_all_properties_to_be_tested(cls: schema.Class, lookup: typing.Dict[str, schema.Class]) -> \
+        typing.Iterable[ql.PropertyForTest]:
+    for c, p in _get_all_properties(cls, lookup):
+        if not ("qltest_skip" in c.pragmas or "qltest_skip" in p.pragmas):
+            # TODO here operations are duplicated, but should be better if we split ql and qltest generation
+            p = get_ql_property(cls, c, p)
            yield ql.PropertyForTest(p.getter, p.type, p.is_single, p.is_predicate, p.is_repeated)


@@ -184,17 +190,18 @@ def _partition(l, pred):
    return map(list, _partition_iter(l, pred))


-def _is_in_qltest_collapsed_hierachy(cls: ql.Class, lookup: typing.Dict[str, ql.Class]):
-    return cls.qltest_collapse_hierarchy or _is_under_qltest_collapsed_hierachy(cls, lookup)
+def _is_in_qltest_collapsed_hierachy(cls: schema.Class, lookup: typing.Dict[str, schema.Class]):
+    return "qltest_collapse_hierarchy" in cls.pragmas or _is_under_qltest_collapsed_hierachy(cls, lookup)


-def _is_under_qltest_collapsed_hierachy(cls: ql.Class, lookup: typing.Dict[str, ql.Class]):
-    return not cls.qltest_uncollapse_hierarchy and any(
+def _is_under_qltest_collapsed_hierachy(cls: schema.Class, lookup: typing.Dict[str, schema.Class]):
+    return "qltest_uncollapse_hierarchy" not in cls.pragmas and any(
        _is_in_qltest_collapsed_hierachy(lookup[b], lookup) for b in cls.bases)


-def _should_skip_qltest(cls: ql.Class, lookup: typing.Dict[str, ql.Class]):
-    return cls.qltest_skip or not (cls.final or cls.qltest_collapse_hierarchy) or _is_under_qltest_collapsed_hierachy(
+def _should_skip_qltest(cls: schema.Class, lookup: typing.Dict[str, schema.Class]):
+    return "qltest_skip" in cls.pragmas or not (
+            cls.final or "qltest_collapse_hierarchy" in cls.pragmas) or _is_under_qltest_collapsed_hierachy(
        cls, lookup)


@@ -211,12 +218,14 @@ def generate(opts, renderer):
    existing |= {q for q in test_out.rglob(missing_test_source_filename)}

    data = schema.load(input)
-    data.classes.sort(key=lambda cls: (cls.dir, cls.name))
+    inheritance_graph = {name: cls.bases for name, cls in data.classes.items()}
+    input_classes = [data.classes[name] for name in toposort_flatten(inheritance_graph)]

-    classes = [get_ql_class(cls) for cls in data.classes]
-    lookup = {cls.name: cls for cls in classes}
+    classes = [get_ql_class(cls, data.classes) for cls in input_classes]
    imports = {}

+    renderer.render(ql.DbClasses(cls for cls in classes if not cls.ipa), out / "Db.qll")
+
    for c in classes:
        imports[c.name] = get_import(stub_out / c.path, opts.swift_dir)

@@ -237,17 +246,17 @@ def generate(opts, renderer):
    renderer.render(ql.GetParentImplementation(
        classes), out / 'GetImmediateParent.qll')

-    for c in classes:
-        if _should_skip_qltest(c, lookup):
+    for c in input_classes:
+        if _should_skip_qltest(c, data.classes):
            continue
-        test_dir = test_out / c.path
+        test_dir = test_out / c.dir / c.name
        test_dir.mkdir(parents=True, exist_ok=True)
        if not any(test_dir.glob("*.swift")):
-            log.warning(f"no test source in {c.path}")
+            log.warning(f"no test source in {c.dir / c.name}")
            renderer.render(ql.MissingTestInstructions(),
                            test_dir / missing_test_source_filename)
            continue
-        total_props, partial_props = _partition(_get_all_properties_to_be_tested(c, lookup),
+        total_props, partial_props = _partition(_get_all_properties_to_be_tested(c, data.classes),
                                                lambda p: p.is_single or p.is_predicate)
        renderer.render(ql.ClassTester(class_name=c.name,
                                       properties=total_props), test_dir / f"{c.name}.ql")
@@ -258,16 +267,16 @@ def generate(opts, renderer):
    final_ipa_types = []
    non_final_ipa_types = []
    constructor_imports = []
-    for cls in data.classes:
+    for cls in input_classes:
        ipa_type = get_ql_ipa_class(cls)
        if ipa_type.is_final:
            final_ipa_types.append(ipa_type)
-            if ipa_type.is_ipa:
+            if ipa_type.is_ipa_from or (ipa_type.is_ipa_on 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)
                constructor_imports.append(get_import(stub_file, opts.swift_dir))
-        else:
+        elif cls.name != schema.root_class_name:
            non_final_ipa_types.append(ipa_type)

    renderer.render(ql.Ipa.Types(schema.root_class_name, final_ipa_types, non_final_ipa_types), out / "IpaTypes.qll")
--- a/swift/codegen/lib/ql.py
+++ b/swift/codegen/lib/ql.py
@@ -14,7 +14,7 @@ left behind and must be dealt with by hand.

 import pathlib
 from dataclasses import dataclass, field
-from typing import List, ClassVar, Union
+from typing import List, ClassVar, Union, Optional

 import inflection

@@ -28,12 +28,11 @@ class Param:
@dataclass
 class Property:
    singular: str
-    type: str = None
-    tablename: str = None
+    type: Optional[str] = None
+    tablename: Optional[str] = None
    tableparams: List[Param] = field(default_factory=list)
-    plural: str = None
+    plural: Optional[str] = None
    first: bool = False
-    local_var: str = "x"
    is_optional: bool = False
    is_predicate: bool = False
    is_child: bool = False
@@ -41,8 +40,6 @@ class Property:

    def __post_init__(self):
        if self.tableparams:
-            if self.type_is_class:
-                self.tableparams = [x if x != "result" else self.local_var for x in self.tableparams]
            self.tableparams = [Param(x) for x in self.tableparams]
            self.tableparams[0].first = True

@@ -82,6 +79,8 @@ class Class:
    qltest_skip: bool = False
    qltest_collapse_hierarchy: bool = False
    qltest_uncollapse_hierarchy: bool = False
+    has_db_id: bool = False
+    ipa: bool = False

    def __post_init__(self):
        self.bases = sorted(self.bases)
@@ -89,17 +88,18 @@ class Class:
            self.properties[0].first = True

    @property
-    def db_id(self):
-        return "@" + inflection.underscore(self.name)
-
-    @property
-    def root(self):
+    def root(self) -> bool:
        return not self.bases

    @property
-    def path(self):
+    def path(self) -> pathlib.Path:
        return self.dir / self.name

+    @property
+    def db_id(self) -> Optional[str]:
+        if self.has_db_id:
+            return "@" + inflection.underscore(self.name)
+

@dataclass
 class Stub:
@@ -109,6 +109,13 @@ class Stub:
    base_import: str


+@dataclass
+class DbClasses:
+    template: ClassVar = 'ql_db'
+
+    classes: List[Class] = field(default_factory=list)
+
+
@dataclass
 class ImportList:
    template: ClassVar = 'ql_imports'
@@ -126,7 +133,7 @@ class GetParentImplementation:
@dataclass
 class PropertyForTest:
    getter: str
-    type: str = None
+    type: Optional[str] = None
    is_single: bool = False
    is_predicate: bool = False
    is_repeated: bool = False
@@ -198,6 +205,10 @@ class Ipa:
            if self.params:
                self.params[0].first = True

+        @property
+        def has_params(self) -> bool:
+            return bool(self.params)
+
    @dataclass
    class FinalClassDb(FinalClass):
        is_db: ClassVar = True
--- a/swift/codegen/lib/schema.py
+++ b/swift/codegen/lib/schema.py
@@ -3,7 +3,7 @@
 import pathlib
 import re
 from dataclasses import dataclass, field
-from typing import List, Set, Union, Dict, ClassVar
+from typing import List, Set, Union, Dict, ClassVar, Optional

 import yaml

@@ -58,8 +58,8 @@ class PredicateProperty(Property):

@dataclass
 class IpaInfo:
-    from_class: str = None
-    on_arguments: Dict[str, str] = None
+    from_class: Optional[str] = None
+    on_arguments: Optional[Dict[str, str]] = None


@dataclass
@@ -70,12 +70,16 @@ class Class:
    properties: List[Property] = field(default_factory=list)
    dir: pathlib.Path = pathlib.Path()
    pragmas: List[str] = field(default_factory=list)
-    ipa: IpaInfo = None
+    ipa: Optional[IpaInfo] = None
+
+    @property
+    def final(self):
+        return not self.derived


@dataclass
 class Schema:
-    classes: List[Class]
+    classes: Dict[str, Class]
    includes: Set[str] = field(default_factory=set)


@@ -164,4 +168,4 @@ def load(path):
            cls.bases.add(root_class_name)
            classes[root_class_name].derived.add(name)

-    return Schema(classes=list(classes.values()), includes=set(data.get("_includes", [])))
+    return Schema(classes=classes, includes=set(data.get("_includes", [])))
--- a/swift/codegen/schema.yml
+++ b/swift/codegen/schema.yml
@@ -19,6 +19,15 @@ Element:

 File:
  name: string
+  _pragma: qltest_collapse_hierarchy
+
+DbFile:
+  _extends: File
+
+UnknownFile:
+  _extends: File
+  _ipa:
+    on: {}

 Locatable:
  location:
@@ -32,7 +41,15 @@ Location:
  start_column: int
  end_line: int
  end_column: int
-  _pragma: qltest_skip
+  _pragma: [qltest_skip, qltest_collapse_hierarchy]
+
+DbLocation:
+  _extends: Location
+
+UnknownLocation:
+  _extends: Location
+  _ipa:
+    on: {}

 Type:
  name: string
@@ -792,11 +809,11 @@ OptionalTryExpr:
 TryExpr:
  _extends: AnyTryExpr

-MethodCallExpr:
-  _extends: ApplyExpr
-  _ipa:
-    from: CallExpr
-  qualifier: Expr
+#MethodCallExpr:
+#  _extends: ApplyExpr
+#  _ipa:
+#    from: CallExpr
+#  qualifier: Expr

 BinaryExpr:
  _extends: ApplyExpr
--- a/swift/codegen/templates/ql_class.mustache
+++ b/swift/codegen/templates/ql_class.mustache
@@ -1,9 +1,11 @@
 // generated by {{generator}}
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 {{#imports}}
 import {{.}}
 {{/imports}}

-class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
+class {{name}}Base extends Cached::T{{name}}{{#bases}}, {{.}}{{/bases}} {
  {{#root}}
  string toString() { none() } // overridden by subclasses

@@ -18,37 +20,57 @@ class {{name}}Base extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
    or
    result = getResolveStep().resolve()
  }
+
+  Db::Element asDbInstance() { none() }
  {{/root}}
  {{#final}}
+  {{#has_db_id}}
+  final override Db::{{name}} asDbInstance() { this = Cached::T{{name}}(result) }
+  {{/has_db_id}}
+
  override string getAPrimaryQlClass() { result = "{{name}}" }
  {{/final}}
  {{#properties}}

-  {{type}} {{getter}}({{#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}}
-    {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
-    {{/type_is_class}}
+  {{#type_is_class}}
+  {{type}} getImmediate{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
+    {{#has_db_id}}
+    result = Cached::fromDbInstance(asDbInstance().(Db::{{name}}).{{getter}}({{#is_repeated}}index{{/is_repeated}}))
+    {{/has_db_id}}
+    {{^has_db_id}}
+    none()
+    {{/has_db_id}}
  }
-  {{#is_optional}}

-  predicate has{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
+  final {{type}} {{getter}}({{#is_repeated}}int index{{/is_repeated}}) {
+    result = getImmediate{{singular}}({{#is_repeated}}index{{/is_repeated}}).resolve()
+  }
+
+  {{/type_is_class}}
+  {{^type_is_class}}
+  {{type}} {{getter}}({{#is_repeated}}int index{{/is_repeated}}) {
+    {{#has_db_id}}
+    {{^is_predicate}}result = {{/is_predicate}}asDbInstance().(Db::{{name}}).{{getter}}({{#is_repeated}}index{{/is_repeated}})
+    {{/has_db_id}}
+    {{^has_db_id}}
+    none()
+    {{/has_db_id}}
+  }
+
+  {{/type_is_class}}
+  {{#is_optional}}
+  final predicate has{{singular}}({{#is_repeated}}int index{{/is_repeated}}) {
    exists({{getter}}({{#is_repeated}}index{{/is_repeated}}))
  }
  {{/is_optional}}
  {{#is_repeated}}

-  {{type}} {{indefinite_getter}}() {
+  final {{type}} {{indefinite_getter}}() {
    result = {{getter}}(_)
  }
  {{^is_optional}}

-  int getNumberOf{{plural}}() {
+  final int getNumberOf{{plural}}() {
    result = count({{indefinite_getter}}())
  }
  {{/is_optional}}
--- a/swift/codegen/templates/ql_db.mustache
+++ b/swift/codegen/templates/ql_db.mustache
@@ -0,0 +1,15 @@
+module Db {
+  {{#classes}}
+  class {{name}} extends {{db_id}}{{#bases}}, {{.}}{{/bases}} {
+    {{#root}}string toString() { none() }{{/root}}
+    {{#final}}override string toString() { result = "{{name}}" }{{/final}}
+
+    {{#properties}}
+    {{type}} {{getter}}({{#is_repeated}}int index{{/is_repeated}}) {
+      {{tablename}}({{#tableparams}}{{^first}}, {{/first}}{{param}}{{/tableparams}})
+    }
+    {{/properties}}
+  }
+
+  {{/classes}}
+}
--- a/swift/codegen/templates/ql_ipa_types.mustache
+++ b/swift/codegen/templates/ql_ipa_types.mustache
@@ -1,4 +1,5 @@
-private import codeql.swift.elements.IpaConstructors
+private import codeql.swift.generated.IpaConstructors
+private import codeql.swift.generated.Db

 cached module Cached {
  cached newtype T{{root}} =
@@ -10,14 +11,24 @@ cached module Cached {
    T{{name}}({{type}} id) { construct{{name}}(id) }
    {{/is_ipa_from}}
    {{#is_ipa_on}}
-    T{{name}}({{#params}}{{^first}}, {{/first}}{{type}} {{param}}{{/params}}) { construct{{name}}({{#params}}{{^first}}, {{/first}}{{param}}{{/params}}) }
+    T{{name}}({{#params}}{{^first}}, {{/first}}{{type}} {{param}}{{/params}}){{#has_params}} { construct{{name}}({{#params}}{{^first}}, {{/first}}{{param}}{{/params}}) }{{/has_params}}
    {{/is_ipa_on}}
    {{#is_db}}
-    T{{name}}({{db_id}} id){{#has_subtracted_ipa_types}} { {{#subtracted_ipa_types}}{{^first}} and {{/first}}not construct{{name}}(id){{/subtracted_ipa_types}} }{{/has_subtracted_ipa_types}}
+    T{{name}}(Db::{{name}} id){{#has_subtracted_ipa_types}} { {{#subtracted_ipa_types}}{{^first}} and {{/first}}not construct{{name}}(id){{/subtracted_ipa_types}} }{{/has_subtracted_ipa_types}}
    {{/is_db}}
    {{/final_classes}}

  {{#non_final_classes}}
  class T{{name}} = {{#derived}}{{^first}} or {{/first}}T{{name}}{{/derived}};
  {{/non_final_classes}}
+
+  cached TElement fromDbInstance(Db::Element e) {
+    none()
+    {{#final_classes}}
+    {{^is_ipa_on}}
+    or
+    result = T{{name}}(e)
+    {{/is_ipa_on}}
+    {{/final_classes}}
+  }
 }
--- a/swift/codegen/templates/ql_parent.mustache
+++ b/swift/codegen/templates/ql_parent.mustache
@@ -1,6 +1,6 @@
 // generated by {{generator}}

-import codeql.swift.elements.Element
+import codeql.swift.elements

 /**
 * Gets any of the "immediate" children of `e`. "Immediate" means not taking into account node resolution: for example
@@ -11,25 +11,16 @@ import codeql.swift.elements.Element
 cached
 Element getAnImmediateChild(Element e) {
  // why does this look more complicated than it should?
-  // * `exists` and the `x` variable are there to reuse the same generation done in classes (where `x` is used to hide
-  //   nodes via resolution)
  // * none() simplifies generation, as we can append `or ...` without a special case for the first item
-  exists(Element x | result = x and (
-    none()
-    {{#classes}}
-    {{#properties}}
-    {{#is_child}}
-    or
-    {{#is_repeated}}
-    {{tablename}}(e, _, x)
-    {{/is_repeated}}
-    {{^is_repeated}}
-    {{tablename}}(e{{#tableparams}}{{^first}}, {{param}}{{/first}}{{/tableparams}})
-    {{/is_repeated}}
-    {{/is_child}}
-    {{/properties}}
-    {{/classes}}
-  ))
+  none()
+  {{#classes}}
+  {{#properties}}
+  {{#is_child}}
+  or
+  result = e.({{name}}).getImmediate{{singular}}({{#is_repeated}}_{{/is_repeated}})
+  {{/is_child}}
+  {{/properties}}
+  {{/classes}}
 }

 /**
--- a/swift/codegen/test/test_cppgen.py
+++ b/swift/codegen/test/test_cppgen.py
@@ -12,7 +12,7 @@ def generate_grouped(opts, renderer, input):
    opts.cpp_output = output_dir

    def ret(classes):
-        input.classes = classes
+        input.classes = {cls.name: cls for cls in classes}
        generated = run_generation(cppgen.generate, opts, renderer)
        for f, g in generated.items():
            assert isinstance(g, cpp.ClassList), f
--- a/swift/codegen/test/test_dbschemegen.py
+++ b/swift/codegen/test/test_dbschemegen.py
@@ -8,7 +8,6 @@ from swift.codegen.generators import dbschemegen
 from swift.codegen.lib import dbscheme
 from swift.codegen.test.utils import *

-
 InputExpectedPair = collections.namedtuple("InputExpectedPair", ("input", "expected"))


@@ -20,27 +19,32 @@ def dir_param(request):
    return request.param


-def generate(opts, renderer):
-    (out, data), = run_generation(dbschemegen.generate, opts, renderer).items()
-    assert out is opts.dbscheme
-    return data
+@pytest.fixture
+def generate(opts, input, renderer):
+    def func(classes):
+        input.classes = {cls.name: cls for cls in classes}
+        (out, data), = run_generation(dbschemegen.generate, opts, renderer).items()
+        assert out is opts.dbscheme
+        return data
+
+    return func


-def test_empty(opts, input, renderer):
-    assert generate(opts, renderer) == dbscheme.Scheme(
+def test_empty(generate):
+    assert generate([]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[],
    )


-def test_includes(opts, input, renderer):
+def test_includes(input, opts, generate):
    includes = ["foo", "bar"]
    input.includes = includes
    for i in includes:
        write(opts.schema.parent / i, i + " data")

-    assert generate(opts, renderer) == dbscheme.Scheme(
+    assert generate([]) == dbscheme.Scheme(
        src=schema_file,
        includes=[
            dbscheme.SchemeInclude(
@@ -52,11 +56,10 @@ def test_includes(opts, input, renderer):
    )


-def test_empty_final_class(opts, input, renderer, dir_param):
-    input.classes = [
+def test_empty_final_class(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -71,14 +74,12 @@ def test_empty_final_class(opts, input, renderer, dir_param):
    )


-def test_final_class_with_single_scalar_field(opts, input, renderer, dir_param):
-    input.classes = [
-
+def test_final_class_with_single_scalar_field(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            schema.SingleProperty("foo", "bar"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -93,13 +94,12 @@ def test_final_class_with_single_scalar_field(opts, input, renderer, dir_param):
    )


-def test_final_class_with_single_class_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_single_class_field(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            schema.SingleProperty("foo", "Bar"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -114,13 +114,12 @@ def test_final_class_with_single_class_field(opts, input, renderer, dir_param):
    )


-def test_final_class_with_optional_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_optional_field(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            schema.OptionalProperty("foo", "bar"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -143,13 +142,12 @@ def test_final_class_with_optional_field(opts, input, renderer, dir_param):


@pytest.mark.parametrize("property_cls", [schema.RepeatedProperty, schema.RepeatedOptionalProperty])
-def test_final_class_with_repeated_field(opts, input, renderer, property_cls, dir_param):
-    input.classes = [
+def test_final_class_with_repeated_field(generate, property_cls, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            property_cls("foo", "bar"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -172,13 +170,12 @@ def test_final_class_with_repeated_field(opts, input, renderer, property_cls, di
    )


-def test_final_class_with_predicate_field(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_predicate_field(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            schema.PredicateProperty("foo"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -199,8 +196,8 @@ def test_final_class_with_predicate_field(opts, input, renderer, dir_param):
    )


-def test_final_class_with_more_fields(opts, input, renderer, dir_param):
-    input.classes = [
+def test_final_class_with_more_fields(generate, dir_param):
+    assert generate([
        schema.Class("Object", dir=dir_param.input, properties=[
            schema.SingleProperty("one", "x"),
            schema.SingleProperty("two", "y"),
@@ -209,8 +206,7 @@ def test_final_class_with_more_fields(opts, input, renderer, dir_param):
            schema.RepeatedOptionalProperty("five", "v"),
            schema.PredicateProperty("six"),
        ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -259,12 +255,11 @@ def test_final_class_with_more_fields(opts, input, renderer, dir_param):
    )


-def test_empty_class_with_derived(opts, input, renderer):
-    input.classes = [
+def test_empty_class_with_derived(generate):
+    assert generate([
        schema.Class(
            name="Base", derived={"Left", "Right"}),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -276,8 +271,8 @@ def test_empty_class_with_derived(opts, input, renderer):
    )


-def test_class_with_derived_and_single_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_single_property(generate, dir_param):
+    assert generate([
        schema.Class(
            name="Base",
            derived={"Left", "Right"},
@@ -285,8 +280,7 @@ def test_class_with_derived_and_single_property(opts, input, renderer, dir_param
            properties=[
                schema.SingleProperty("single", "Prop"),
            ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -307,8 +301,8 @@ def test_class_with_derived_and_single_property(opts, input, renderer, dir_param
    )


-def test_class_with_derived_and_optional_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_optional_property(generate, dir_param):
+    assert generate([
        schema.Class(
            name="Base",
            derived={"Left", "Right"},
@@ -316,8 +310,7 @@ def test_class_with_derived_and_optional_property(opts, input, renderer, dir_par
            properties=[
                schema.OptionalProperty("opt", "Prop"),
            ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
@@ -338,8 +331,8 @@ def test_class_with_derived_and_optional_property(opts, input, renderer, dir_par
    )


-def test_class_with_derived_and_repeated_property(opts, input, renderer, dir_param):
-    input.classes = [
+def test_class_with_derived_and_repeated_property(generate, dir_param):
+    assert generate([
        schema.Class(
            name="Base",
            dir=dir_param.input,
@@ -347,8 +340,7 @@ def test_class_with_derived_and_repeated_property(opts, input, renderer, dir_par
            properties=[
                schema.RepeatedProperty("rep", "Prop"),
            ]),
-    ]
-    assert generate(opts, renderer) == dbscheme.Scheme(
+    ]) == dbscheme.Scheme(
        src=schema_file,
        includes=[],
        declarations=[
--- a/swift/codegen/test/test_ql.py
+++ b/swift/codegen/test/test_ql.py
@@ -94,11 +94,6 @@ def test_class_has_first_property_marked():
    assert cls.properties == expected


-def test_class_db_id():
-    cls = ql.Class("ThisIsMyClass")
-    assert cls.db_id == "@this_is_my_class"
-
-
 def test_root_class():
    cls = ql.Class("Class")
    assert cls.root
--- a/swift/codegen/test/test_qlgen.py
+++ b/swift/codegen/test/test_qlgen.py
@@ -52,7 +52,7 @@ def generate(input, qlgen_opts, renderer):
    renderer.written = []

    def func(classes):
-        input.classes = classes
+        input.classes = {cls.name: cls for cls in classes}
        return run_generation(qlgen.generate, qlgen_opts, renderer)

    return func
@@ -139,7 +139,7 @@ def test_one_empty_class(generate_classes):
        schema.Class("A")
    ]) == {
        "A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "A"),
-                  ql.Class(name="A", final=True)),
+                  ql.Class(name="A", final=True, fields=[ql.Field('id', type='@a')])),
    }


@@ -157,7 +157,7 @@ def test_hierarchy(generate_classes):
        "C.qll": (ql.Stub(name="C", base_import=gen_import_prefix + "C"),
                  ql.Class(name="C", bases=["A"], imports=[stub_import_prefix + "A"])),
        "D.qll": (ql.Stub(name="D", base_import=gen_import_prefix + "D"),
-                  ql.Class(name="D", final=True, bases=["B", "C"],
+                  ql.Class(name="D", final=True, bases=["B", "C"], fields=[ql.Field("id", type="@d")],
                           imports=[stub_import_prefix + cls for cls in "BC"])),
    }

@@ -183,7 +183,7 @@ def test_hierarchy_children(generate_children_implementations):
                     stub_import_prefix + "A"]),
                 ql.Class(name="C", bases=["A"], imports=[
                     stub_import_prefix + "A"]),
-                 ql.Class(name="D", final=True, bases=["B", "C"],
+                 ql.Class(name="D", final=True, bases=["B", "C"], fields=[ql.Field("id", type="@d")],
                          imports=[stub_import_prefix + cls for cls in "BC"]),
                 ],
    )
@@ -195,9 +195,10 @@ def test_single_property(generate_classes):
            schema.SingleProperty("foo", "bar")]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")],
+                                  properties=[
                             ql.Property(singular="Foo", type="bar", tablename="my_objects",
-                                         tableparams=["this", "result"]),
+                                         tableparams=["id", "result"]),
                         ])),
    }

@@ -211,13 +212,14 @@ def test_single_properties(generate_classes):
        ]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")],
+                                  properties=[
                             ql.Property(singular="One", type="x", tablename="my_objects",
-                                         tableparams=["this", "result", "_", "_"]),
+                                         tableparams=["id", "result", "_", "_"]),
                             ql.Property(singular="Two", type="y", tablename="my_objects",
-                                         tableparams=["this", "_", "result", "_"]),
+                                         tableparams=["id", "_", "result", "_"]),
                             ql.Property(singular="Three", type="z", tablename="my_objects",
-                                         tableparams=["this", "_", "_", "result"]),
+                                         tableparams=["id", "_", "_", "result"]),
                         ])),
    }

@@ -229,9 +231,9 @@ def test_optional_property(generate_classes, is_child):
            schema.OptionalProperty("foo", "bar", is_child=is_child)]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                             ql.Property(singular="Foo", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "result"],
+                                         tableparams=["id", "result"],
                                         is_optional=True, is_child=is_child),
                         ])),
    }
@@ -244,9 +246,9 @@ def test_repeated_property(generate_classes, is_child):
            schema.RepeatedProperty("foo", "bar", is_child=is_child)]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                             ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "index", "result"], is_child=is_child),
+                                         tableparams=["id", "index", "result"], is_child=is_child),
                         ])),
    }

@@ -258,9 +260,9 @@ def test_repeated_optional_property(generate_classes, is_child):
            schema.RepeatedOptionalProperty("foo", "bar", is_child=is_child)]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                             ql.Property(singular="Foo", plural="Foos", type="bar", tablename="my_object_foos",
-                                         tableparams=["this", "index", "result"], is_optional=True,
+                                         tableparams=["id", "index", "result"], is_optional=True,
                                         is_child=is_child),
                         ])),
    }
@@ -272,9 +274,9 @@ def test_predicate_property(generate_classes):
            schema.PredicateProperty("is_foo")]),
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
-                         ql.Class(name="MyObject", final=True, properties=[
+                         ql.Class(name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], properties=[
                             ql.Property(singular="isFoo", type="predicate", tablename="my_object_is_foo",
-                                         tableparams=["this"],
+                                         tableparams=["id"],
                                         is_predicate=True),
                         ])),
    }
@@ -289,15 +291,15 @@ def test_single_class_property(generate_classes, is_child):
    ]) == {
        "MyObject.qll": (ql.Stub(name="MyObject", base_import=gen_import_prefix + "MyObject"),
                         ql.Class(
-            name="MyObject", final=True, imports=[stub_import_prefix + "Bar"], properties=[
+            name="MyObject", final=True, fields=[ql.Field("id", type="@my_object")], imports=[stub_import_prefix + "Bar"], properties=[
                ql.Property(singular="Foo", type="Bar", tablename="my_objects",
                            tableparams=[
-                                "this", "result"],
+                                "id", "result"],
                            is_child=is_child),
            ],
        )),
        "Bar.qll": (ql.Stub(name="Bar", base_import=gen_import_prefix + "Bar"),
-                    ql.Class(name="Bar", final=True)),
+                    ql.Class(name="Bar", final=True, fields=[ql.Field("id", type="@bar")])),
    }


@@ -310,7 +312,7 @@ def test_class_dir(generate_classes):
        f"{dir}/A.qll": (ql.Stub(name="A", base_import=gen_import_prefix + "another.rel.path.A"),
                         ql.Class(name="A", dir=dir)),
        "B.qll": (ql.Stub(name="B", base_import=gen_import_prefix + "B"),
-                  ql.Class(name="B", final=True, bases=["A"],
+                  ql.Class(name="B", final=True, fields=[ql.Field("id", type="@b")], bases=["A"],
                           imports=[stub_import_prefix + "another.rel.path.A"])),
    }

--- a/swift/codegen/test/test_schema.py
+++ b/swift/codegen/test/test_schema.py
@@ -20,7 +20,7 @@ def load(tmp_path):

 def test_empty_schema(load):
    ret = load("{}")
-    assert ret.classes == [schema.Class(root_name)]
+    assert ret.classes == {root_name: schema.Class(root_name)}
    assert ret.includes == set()


@@ -28,10 +28,10 @@ def test_one_empty_class(load):
    ret = load("""
 MyClass: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}),
+    }


 def test_two_empty_classes(load):
@@ -39,11 +39,11 @@ def test_two_empty_classes(load):
 MyClass1: {}
 MyClass2: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass1', 'MyClass2'}),
-        schema.Class('MyClass1', bases={root_name}),
-        schema.Class('MyClass2', bases={root_name}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass1', 'MyClass2'}),
+        'MyClass1': schema.Class('MyClass1', bases={root_name}),
+        'MyClass2': schema.Class('MyClass2', bases={root_name}),
+    }


 def test_two_empty_chained_classes(load):
@@ -52,11 +52,11 @@ MyClass1: {}
 MyClass2:
    _extends: MyClass1
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass1'}),
-        schema.Class('MyClass1', bases={root_name}, derived={'MyClass2'}),
-        schema.Class('MyClass2', bases={'MyClass1'}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass1'}),
+        'MyClass1': schema.Class('MyClass1', bases={root_name}, derived={'MyClass2'}),
+        'MyClass2': schema.Class('MyClass2', bases={'MyClass1'}),
+    }


 def test_empty_classes_diamond(load):
@@ -68,12 +68,12 @@ C:
        - A
        - B
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A', 'B'}),
-        schema.Class('A', bases={root_name}, derived={'C'}),
-        schema.Class('B', bases={root_name}, derived={'C'}),
-        schema.Class('C', bases={'A', 'B'}),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A', 'B'}),
+        'A': schema.Class('A', bases={root_name}, derived={'C'}),
+        'B': schema.Class('B', bases={root_name}, derived={'C'}),
+        'C': schema.Class('C', bases={'A', 'B'}),
+    }


 def test_dir(load):
@@ -81,10 +81,10 @@ def test_dir(load):
 A:
    _dir: other/dir
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
+    }


 def test_directory_filter(load):
@@ -101,16 +101,16 @@ Ax: {}
 Ay: {}
 A: {}
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'Afoo', 'Bbar', 'Abar', 'Bfoo', 'Ax', 'Ay', 'A'}),
-        schema.Class('Afoo', bases={root_name}, dir=pathlib.Path("second/dir")),
-        schema.Class('Bbar', bases={root_name}, dir=pathlib.Path("third/dir")),
-        schema.Class('Abar', bases={root_name}, dir=pathlib.Path("third/dir")),
-        schema.Class('Bfoo', bases={root_name}, dir=pathlib.Path("second/dir")),
-        schema.Class('Ax', bases={root_name}, dir=pathlib.Path("first/dir")),
-        schema.Class('Ay', bases={root_name}, dir=pathlib.Path("first/dir")),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path()),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'Afoo', 'Bbar', 'Abar', 'Bfoo', 'Ax', 'Ay', 'A'}),
+        'Afoo': schema.Class('Afoo', bases={root_name}, dir=pathlib.Path("second/dir")),
+        'Bbar': schema.Class('Bbar', bases={root_name}, dir=pathlib.Path("third/dir")),
+        'Abar': schema.Class('Abar', bases={root_name}, dir=pathlib.Path("third/dir")),
+        'Bfoo': schema.Class('Bfoo', bases={root_name}, dir=pathlib.Path("second/dir")),
+        'Ax': schema.Class('Ax', bases={root_name}, dir=pathlib.Path("first/dir")),
+        'Ay': schema.Class('Ay', bases={root_name}, dir=pathlib.Path("first/dir")),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path()),
+    }


 def test_directory_filter_override(load):
@@ -120,10 +120,10 @@ _directories:
 A:
    _dir: other/dir
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, dir=pathlib.Path("other/dir")),
+    }


 def test_lowercase_rejected(load):
@@ -145,16 +145,16 @@ A:
     four: x?*
     five: predicate
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.SingleProperty('one', 'string'),
            schema.OptionalProperty('two', 'int'),
            schema.RepeatedProperty('three', 'bool'),
            schema.RepeatedOptionalProperty('four', 'x'),
            schema.PredicateProperty('five'),
        ]),
-    ]
+    }


 def test_element_properties(load):
@@ -162,11 +162,11 @@ def test_element_properties(load):
 Element:
    x: string
 """)
-    assert ret.classes == [
-        schema.Class(root_name, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, properties=[
            schema.SingleProperty('x', 'string'),
        ]),
-    ]
+    }


 def test_children(load):
@@ -180,9 +180,9 @@ A:
        e: E?
        f: F?*
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.SingleProperty('a', 'string'),
            schema.RepeatedProperty('b', 'B'),
            schema.SingleProperty('c', 'C', is_child=True),
@@ -190,7 +190,7 @@ A:
            schema.OptionalProperty('e', 'E', is_child=True),
            schema.RepeatedOptionalProperty('f', 'F', is_child=True),
        ]),
-    ]
+    }


@pytest.mark.parametrize("type", ["string", "int", "boolean", "predicate"])
@@ -209,12 +209,12 @@ A:
    x: 
      type: string*
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.RepeatedProperty('x', 'string'),
        ]),
-    ]
+    }


 def test_property_with_explicit_type_and_pragmas(load):
@@ -224,12 +224,12 @@ A:
      type: string*
      _pragma: [foo, bar]
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.RepeatedProperty('x', 'string', pragmas=["foo", "bar"]),
        ]),
-    ]
+    }


 def test_property_with_explicit_type_and_one_pragma(load):
@@ -239,12 +239,12 @@ A:
      type: string*
      _pragma: foo
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.RepeatedProperty('x', 'string', pragmas=["foo"]),
        ]),
-    ]
+    }


 def test_property_with_explicit_type_and_unknown_metadata(load):
@@ -272,12 +272,12 @@ A:
    x: string*
    _pragma: [foo, bar]
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.RepeatedProperty('x', 'string'),
        ], pragmas=["foo", "bar"]),
-    ]
+    }


 def test_class_with_one_pragma(load):
@@ -286,12 +286,12 @@ A:
    x: string*
    _pragma: foo
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'A'}),
-        schema.Class('A', bases={root_name}, properties=[
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'A'}),
+        'A': schema.Class('A', bases={root_name}, properties=[
            schema.RepeatedProperty('x', 'string'),
        ], pragmas=["foo"]),
-    ]
+    }


 def test_class_with_unknown_metadata(load):
@@ -309,10 +309,10 @@ MyClass:
    _ipa:
        from: A
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(from_class="A")),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(from_class="A")),
+    }


 def test_ipa_class_on(load):
@@ -323,10 +323,10 @@ MyClass:
            x: A
            y: int
 """)
-    assert ret.classes == [
-        schema.Class(root_name, derived={'MyClass'}),
-        schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(on_arguments={"x": "A", "y": "int"})),
-    ]
+    assert ret.classes == {
+        root_name: schema.Class(root_name, derived={'MyClass'}),
+        'MyClass': schema.Class('MyClass', bases={root_name}, ipa=schema.IpaInfo(on_arguments={"x": "A", "y": "int"})),
+    }


 # TODO rejection tests and implementation for malformed `_ipa` clauses
--- a/swift/extractor/SwiftExtractor.cpp
+++ b/swift/extractor/SwiftExtractor.cpp
@@ -104,14 +104,6 @@ static void extractDeclarations(const SwiftExtractorConfiguration& config,
  dumpArgs(*trapTarget, config);
  TrapDomain trap{*trapTarget};

-  // TODO: remove this and recreate it with IPA when we have that
-  // the following cannot conflict with actual files as those have an absolute path starting with /
-  File unknownFileEntry{trap.createLabel<FileTag>("unknown")};
-  Location unknownLocationEntry{trap.createLabel<LocationTag>("unknown")};
-  unknownLocationEntry.file = unknownFileEntry.id;
-  trap.emit(unknownFileEntry);
-  trap.emit(unknownLocationEntry);
-
  SwiftVisitor visitor(compiler.getSourceMgr(), trap, module, primaryFile);
  auto topLevelDecls = getTopLevelDecls(module, primaryFile);
  for (auto decl : topLevelDecls) {
--- a/swift/extractor/infra/SwiftDispatcher.h
+++ b/swift/extractor/infra/SwiftDispatcher.h
@@ -251,13 +251,13 @@ class SwiftDispatcher {
      return;
    }
    auto file = getFilePath(sourceManager.getDisplayNameForLoc(start));
-    Location entry{{}};
+    DbLocation entry{{}};
    entry.file = fetchLabel(file);
    std::tie(entry.start_line, entry.start_column) = sourceManager.getLineAndColumnInBuffer(start);
    std::tie(entry.end_line, entry.end_column) = sourceManager.getLineAndColumnInBuffer(end);
-    entry.id = trap.createLabel<LocationTag>('{', entry.file, "}:", entry.start_line, ':',
-                                             entry.start_column, ':', entry.end_line, ':',
-                                             entry.end_column);
+    entry.id = trap.createLabel<DbLocationTag>('{', entry.file, "}:", entry.start_line, ':',
+                                               entry.start_column, ':', entry.end_line, ':',
+                                               entry.end_column);
    emit(entry);
    emit(LocatableLocationsTrap{locatableLabel, entry.id});
  }
--- a/swift/extractor/infra/SwiftTagTraits.h
+++ b/swift/extractor/infra/SwiftTagTraits.h
@@ -69,7 +69,7 @@ MAP_TYPE_TO_TAG(swift::TypeBase, TypeTag);
 OVERRIDE_TAG(FuncDecl, ConcreteFuncDeclTag);
 OVERRIDE_TAG(VarDecl, ConcreteVarDeclTag);

-MAP_TYPE_TO_TAG(FilePath, FileTag);
+MAP_TYPE_TO_TAG(FilePath, DbFileTag);

 #undef MAP_TAG
 #undef MAP_SUBTAG
--- a/swift/ql/lib/codeql/swift/elements.qll
+++ b/swift/ql/lib/codeql/swift/elements.qll
@@ -1,284 +1,287 @@
 // generated by codegen/codegen.py
-import codeql.swift.elements.AstNode
-import codeql.swift.elements.Callable
 import codeql.swift.elements.Element
+import codeql.swift.elements.Callable
 import codeql.swift.elements.File
+import codeql.swift.elements.decl.GenericContext
+import codeql.swift.elements.decl.IterableDeclContext
 import codeql.swift.elements.Locatable
 import codeql.swift.elements.Location
-import codeql.swift.elements.decl.AbstractFunctionDecl
-import codeql.swift.elements.decl.AbstractStorageDecl
-import codeql.swift.elements.decl.AbstractTypeParamDecl
-import codeql.swift.elements.decl.AccessorDecl
-import codeql.swift.elements.decl.AssociatedTypeDecl
-import codeql.swift.elements.decl.ClassDecl
-import codeql.swift.elements.decl.ConcreteFuncDecl
-import codeql.swift.elements.decl.ConcreteVarDecl
-import codeql.swift.elements.decl.ConstructorDecl
-import codeql.swift.elements.decl.Decl
-import codeql.swift.elements.decl.DestructorDecl
-import codeql.swift.elements.decl.EnumCaseDecl
-import codeql.swift.elements.decl.EnumDecl
-import codeql.swift.elements.decl.EnumElementDecl
-import codeql.swift.elements.decl.ExtensionDecl
-import codeql.swift.elements.decl.FuncDecl
-import codeql.swift.elements.decl.GenericContext
-import codeql.swift.elements.decl.GenericTypeDecl
-import codeql.swift.elements.decl.GenericTypeParamDecl
+import codeql.swift.elements.type.Type
+import codeql.swift.elements.type.AnyFunctionType
+import codeql.swift.elements.type.AnyGenericType
+import codeql.swift.elements.type.AnyMetatypeType
+import codeql.swift.elements.expr.Argument
+import codeql.swift.elements.AstNode
+import codeql.swift.elements.type.BuiltinType
+import codeql.swift.elements.stmt.ConditionElement
+import codeql.swift.elements.DbFile
+import codeql.swift.elements.DbLocation
+import codeql.swift.elements.type.DependentMemberType
+import codeql.swift.elements.type.DynamicSelfType
+import codeql.swift.elements.type.ErrorType
+import codeql.swift.elements.type.ExistentialType
 import codeql.swift.elements.decl.IfConfigClause
-import codeql.swift.elements.decl.IfConfigDecl
-import codeql.swift.elements.decl.ImportDecl
-import codeql.swift.elements.decl.InfixOperatorDecl
-import codeql.swift.elements.decl.IterableDeclContext
-import codeql.swift.elements.decl.MissingMemberDecl
-import codeql.swift.elements.decl.ModuleDecl
-import codeql.swift.elements.decl.NominalTypeDecl
-import codeql.swift.elements.decl.OpaqueTypeDecl
-import codeql.swift.elements.decl.OperatorDecl
-import codeql.swift.elements.decl.ParamDecl
-import codeql.swift.elements.decl.PatternBindingDecl
-import codeql.swift.elements.decl.PostfixOperatorDecl
-import codeql.swift.elements.decl.PoundDiagnosticDecl
-import codeql.swift.elements.decl.PrecedenceGroupDecl
-import codeql.swift.elements.decl.PrefixOperatorDecl
-import codeql.swift.elements.decl.ProtocolDecl
-import codeql.swift.elements.decl.StructDecl
-import codeql.swift.elements.decl.SubscriptDecl
-import codeql.swift.elements.decl.TopLevelCodeDecl
-import codeql.swift.elements.decl.TypeAliasDecl
-import codeql.swift.elements.decl.TypeDecl
-import codeql.swift.elements.decl.ValueDecl
-import codeql.swift.elements.decl.VarDecl
+import codeql.swift.elements.type.InOutType
+import codeql.swift.elements.type.LValueType
+import codeql.swift.elements.type.ModuleType
+import codeql.swift.elements.type.PlaceholderType
+import codeql.swift.elements.type.ProtocolCompositionType
+import codeql.swift.elements.type.ReferenceStorageType
+import codeql.swift.elements.type.SilBlockStorageType
+import codeql.swift.elements.type.SilBoxType
+import codeql.swift.elements.type.SilFunctionType
+import codeql.swift.elements.type.SilTokenType
+import codeql.swift.elements.type.SubstitutableType
+import codeql.swift.elements.type.SugarType
+import codeql.swift.elements.type.TupleType
+import codeql.swift.elements.type.TypeVariableType
+import codeql.swift.elements.UnknownFile
+import codeql.swift.elements.UnknownLocation
+import codeql.swift.elements.type.UnresolvedType
+import codeql.swift.elements.type.AnyBuiltinIntegerType
+import codeql.swift.elements.type.ArchetypeType
+import codeql.swift.elements.type.BuiltinBridgeObjectType
+import codeql.swift.elements.type.BuiltinDefaultActorStorageType
+import codeql.swift.elements.type.BuiltinExecutorType
+import codeql.swift.elements.type.BuiltinFloatType
+import codeql.swift.elements.type.BuiltinJobType
+import codeql.swift.elements.type.BuiltinNativeObjectType
+import codeql.swift.elements.type.BuiltinRawPointerType
+import codeql.swift.elements.type.BuiltinRawUnsafeContinuationType
+import codeql.swift.elements.type.BuiltinUnsafeValueBufferType
+import codeql.swift.elements.type.BuiltinVectorType
+import codeql.swift.elements.stmt.CaseLabelItem
+import codeql.swift.elements.decl.Decl
+import codeql.swift.elements.type.ExistentialMetatypeType
+import codeql.swift.elements.expr.Expr
+import codeql.swift.elements.type.FunctionType
+import codeql.swift.elements.type.GenericFunctionType
+import codeql.swift.elements.type.GenericTypeParamType
+import codeql.swift.elements.type.MetatypeType
+import codeql.swift.elements.type.NominalOrBoundGenericNominalType
+import codeql.swift.elements.type.ParenType
+import codeql.swift.elements.pattern.Pattern
+import codeql.swift.elements.stmt.Stmt
+import codeql.swift.elements.stmt.StmtCondition
+import codeql.swift.elements.type.SyntaxSugarType
+import codeql.swift.elements.type.TypeAliasType
+import codeql.swift.elements.type.TypeRepr
+import codeql.swift.elements.type.UnboundGenericType
+import codeql.swift.elements.type.UnmanagedStorageType
+import codeql.swift.elements.type.UnownedStorageType
+import codeql.swift.elements.type.WeakStorageType
 import codeql.swift.elements.expr.AbstractClosureExpr
-import codeql.swift.elements.expr.AnyHashableErasureExpr
+import codeql.swift.elements.pattern.AnyPattern
 import codeql.swift.elements.expr.AnyTryExpr
 import codeql.swift.elements.expr.AppliedPropertyWrapperExpr
 import codeql.swift.elements.expr.ApplyExpr
-import codeql.swift.elements.expr.ArchetypeToSuperExpr
-import codeql.swift.elements.expr.Argument
-import codeql.swift.elements.expr.ArrayExpr
-import codeql.swift.elements.expr.ArrayToPointerExpr
 import codeql.swift.elements.expr.ArrowExpr
 import codeql.swift.elements.expr.AssignExpr
+import codeql.swift.elements.expr.BindOptionalExpr
+import codeql.swift.elements.pattern.BindingPattern
+import codeql.swift.elements.pattern.BoolPattern
+import codeql.swift.elements.type.BoundGenericType
+import codeql.swift.elements.stmt.BraceStmt
+import codeql.swift.elements.stmt.BreakStmt
+import codeql.swift.elements.type.BuiltinIntegerLiteralType
+import codeql.swift.elements.type.BuiltinIntegerType
+import codeql.swift.elements.expr.CaptureListExpr
+import codeql.swift.elements.stmt.CaseStmt
+import codeql.swift.elements.expr.CodeCompletionExpr
+import codeql.swift.elements.expr.CollectionExpr
+import codeql.swift.elements.stmt.ContinueStmt
+import codeql.swift.elements.expr.DeclRefExpr
+import codeql.swift.elements.expr.DefaultArgumentExpr
+import codeql.swift.elements.stmt.DeferStmt
+import codeql.swift.elements.type.DictionaryType
+import codeql.swift.elements.expr.DiscardAssignmentExpr
+import codeql.swift.elements.expr.DotSyntaxBaseIgnoredExpr
+import codeql.swift.elements.expr.DynamicTypeExpr
+import codeql.swift.elements.expr.EditorPlaceholderExpr
+import codeql.swift.elements.decl.EnumCaseDecl
+import codeql.swift.elements.pattern.EnumElementPattern
+import codeql.swift.elements.expr.EnumIsCaseExpr
+import codeql.swift.elements.expr.ErrorExpr
+import codeql.swift.elements.expr.ExplicitCastExpr
+import codeql.swift.elements.pattern.ExprPattern
+import codeql.swift.elements.decl.ExtensionDecl
+import codeql.swift.elements.stmt.FailStmt
+import codeql.swift.elements.stmt.FallthroughStmt
+import codeql.swift.elements.expr.ForceValueExpr
+import codeql.swift.elements.expr.IdentityExpr
+import codeql.swift.elements.decl.IfConfigDecl
+import codeql.swift.elements.expr.IfExpr
+import codeql.swift.elements.expr.ImplicitConversionExpr
+import codeql.swift.elements.decl.ImportDecl
+import codeql.swift.elements.expr.InOutExpr
+import codeql.swift.elements.pattern.IsPattern
+import codeql.swift.elements.expr.KeyPathApplicationExpr
+import codeql.swift.elements.expr.KeyPathDotExpr
+import codeql.swift.elements.expr.KeyPathExpr
+import codeql.swift.elements.stmt.LabeledStmt
+import codeql.swift.elements.expr.LazyInitializerExpr
+import codeql.swift.elements.expr.LiteralExpr
+import codeql.swift.elements.expr.LookupExpr
+import codeql.swift.elements.expr.MakeTemporarilyEscapableExpr
+import codeql.swift.elements.decl.MissingMemberDecl
+import codeql.swift.elements.pattern.NamedPattern
+import codeql.swift.elements.type.NestedArchetypeType
+import codeql.swift.elements.type.NominalType
+import codeql.swift.elements.expr.ObjCSelectorExpr
+import codeql.swift.elements.expr.OneWayExpr
+import codeql.swift.elements.type.OpaqueTypeArchetypeType
+import codeql.swift.elements.expr.OpaqueValueExpr
+import codeql.swift.elements.expr.OpenExistentialExpr
+import codeql.swift.elements.type.OpenedArchetypeType
+import codeql.swift.elements.decl.OperatorDecl
+import codeql.swift.elements.expr.OptionalEvaluationExpr
+import codeql.swift.elements.pattern.OptionalSomePattern
+import codeql.swift.elements.expr.OtherConstructorDeclRefExpr
+import codeql.swift.elements.expr.OverloadSetRefExpr
+import codeql.swift.elements.pattern.ParenPattern
+import codeql.swift.elements.decl.PatternBindingDecl
+import codeql.swift.elements.stmt.PoundAssertStmt
+import codeql.swift.elements.decl.PoundDiagnosticDecl
+import codeql.swift.elements.decl.PrecedenceGroupDecl
+import codeql.swift.elements.type.PrimaryArchetypeType
+import codeql.swift.elements.expr.PropertyWrapperValuePlaceholderExpr
+import codeql.swift.elements.expr.RebindSelfInConstructorExpr
+import codeql.swift.elements.stmt.ReturnStmt
+import codeql.swift.elements.type.SequenceArchetypeType
+import codeql.swift.elements.expr.SequenceExpr
+import codeql.swift.elements.expr.SuperRefExpr
+import codeql.swift.elements.expr.TapExpr
+import codeql.swift.elements.stmt.ThrowStmt
+import codeql.swift.elements.decl.TopLevelCodeDecl
+import codeql.swift.elements.expr.TupleElementExpr
+import codeql.swift.elements.expr.TupleExpr
+import codeql.swift.elements.pattern.TuplePattern
+import codeql.swift.elements.expr.TypeExpr
+import codeql.swift.elements.pattern.TypedPattern
+import codeql.swift.elements.type.UnarySyntaxSugarType
+import codeql.swift.elements.expr.UnresolvedDeclRefExpr
+import codeql.swift.elements.expr.UnresolvedDotExpr
+import codeql.swift.elements.expr.UnresolvedMemberExpr
+import codeql.swift.elements.expr.UnresolvedPatternExpr
+import codeql.swift.elements.expr.UnresolvedSpecializeExpr
+import codeql.swift.elements.decl.ValueDecl
+import codeql.swift.elements.expr.VarargExpansionExpr
+import codeql.swift.elements.stmt.YieldStmt
+import codeql.swift.elements.decl.AbstractFunctionDecl
+import codeql.swift.elements.decl.AbstractStorageDecl
+import codeql.swift.elements.expr.AnyHashableErasureExpr
+import codeql.swift.elements.expr.ArchetypeToSuperExpr
+import codeql.swift.elements.expr.ArrayExpr
+import codeql.swift.elements.type.ArraySliceType
+import codeql.swift.elements.expr.ArrayToPointerExpr
 import codeql.swift.elements.expr.AutoClosureExpr
 import codeql.swift.elements.expr.AwaitExpr
 import codeql.swift.elements.expr.BinaryExpr
-import codeql.swift.elements.expr.BindOptionalExpr
-import codeql.swift.elements.expr.BooleanLiteralExpr
+import codeql.swift.elements.type.BoundGenericClassType
+import codeql.swift.elements.type.BoundGenericEnumType
+import codeql.swift.elements.type.BoundGenericStructType
 import codeql.swift.elements.expr.BridgeFromObjCExpr
 import codeql.swift.elements.expr.BridgeToObjCExpr
 import codeql.swift.elements.expr.BuiltinLiteralExpr
 import codeql.swift.elements.expr.CallExpr
-import codeql.swift.elements.expr.CaptureListExpr
 import codeql.swift.elements.expr.CheckedCastExpr
 import codeql.swift.elements.expr.ClassMetatypeToObjectExpr
+import codeql.swift.elements.type.ClassType
 import codeql.swift.elements.expr.ClosureExpr
-import codeql.swift.elements.expr.CodeCompletionExpr
 import codeql.swift.elements.expr.CoerceExpr
-import codeql.swift.elements.expr.CollectionExpr
 import codeql.swift.elements.expr.CollectionUpcastConversionExpr
 import codeql.swift.elements.expr.ConditionalBridgeFromObjCExpr
-import codeql.swift.elements.expr.ConditionalCheckedCastExpr
-import codeql.swift.elements.expr.ConstructorRefCallExpr
 import codeql.swift.elements.expr.CovariantFunctionConversionExpr
 import codeql.swift.elements.expr.CovariantReturnConversionExpr
-import codeql.swift.elements.expr.DeclRefExpr
-import codeql.swift.elements.expr.DefaultArgumentExpr
 import codeql.swift.elements.expr.DerivedToBaseExpr
 import codeql.swift.elements.expr.DestructureTupleExpr
 import codeql.swift.elements.expr.DictionaryExpr
 import codeql.swift.elements.expr.DifferentiableFunctionExpr
 import codeql.swift.elements.expr.DifferentiableFunctionExtractOriginalExpr
-import codeql.swift.elements.expr.DiscardAssignmentExpr
+import codeql.swift.elements.stmt.DoCatchStmt
+import codeql.swift.elements.stmt.DoStmt
 import codeql.swift.elements.expr.DotSelfExpr
-import codeql.swift.elements.expr.DotSyntaxBaseIgnoredExpr
-import codeql.swift.elements.expr.DotSyntaxCallExpr
 import codeql.swift.elements.expr.DynamicLookupExpr
-import codeql.swift.elements.expr.DynamicMemberRefExpr
-import codeql.swift.elements.expr.DynamicSubscriptExpr
-import codeql.swift.elements.expr.DynamicTypeExpr
-import codeql.swift.elements.expr.EditorPlaceholderExpr
-import codeql.swift.elements.expr.EnumIsCaseExpr
+import codeql.swift.elements.decl.EnumElementDecl
+import codeql.swift.elements.type.EnumType
 import codeql.swift.elements.expr.ErasureExpr
-import codeql.swift.elements.expr.ErrorExpr
 import codeql.swift.elements.expr.ExistentialMetatypeToObjectExpr
-import codeql.swift.elements.expr.ExplicitCastExpr
-import codeql.swift.elements.expr.Expr
-import codeql.swift.elements.expr.FloatLiteralExpr
+import codeql.swift.elements.stmt.ForEachStmt
 import codeql.swift.elements.expr.ForceTryExpr
-import codeql.swift.elements.expr.ForceValueExpr
-import codeql.swift.elements.expr.ForcedCheckedCastExpr
 import codeql.swift.elements.expr.ForeignObjectConversionExpr
 import codeql.swift.elements.expr.FunctionConversionExpr
-import codeql.swift.elements.expr.IdentityExpr
-import codeql.swift.elements.expr.IfExpr
-import codeql.swift.elements.expr.ImplicitConversionExpr
-import codeql.swift.elements.expr.InOutExpr
 import codeql.swift.elements.expr.InOutToPointerExpr
+import codeql.swift.elements.decl.InfixOperatorDecl
 import codeql.swift.elements.expr.InjectIntoOptionalExpr
-import codeql.swift.elements.expr.IntegerLiteralExpr
 import codeql.swift.elements.expr.InterpolatedStringLiteralExpr
-import codeql.swift.elements.expr.IsExpr
-import codeql.swift.elements.expr.KeyPathApplicationExpr
-import codeql.swift.elements.expr.KeyPathDotExpr
-import codeql.swift.elements.expr.KeyPathExpr
-import codeql.swift.elements.expr.LazyInitializerExpr
+import codeql.swift.elements.stmt.LabeledConditionalStmt
 import codeql.swift.elements.expr.LinearFunctionExpr
 import codeql.swift.elements.expr.LinearFunctionExtractOriginalExpr
 import codeql.swift.elements.expr.LinearToDifferentiableFunctionExpr
-import codeql.swift.elements.expr.LiteralExpr
 import codeql.swift.elements.expr.LoadExpr
-import codeql.swift.elements.expr.LookupExpr
-import codeql.swift.elements.expr.MagicIdentifierLiteralExpr
-import codeql.swift.elements.expr.MakeTemporarilyEscapableExpr
 import codeql.swift.elements.expr.MemberRefExpr
 import codeql.swift.elements.expr.MetatypeConversionExpr
-import codeql.swift.elements.expr.MethodCallExpr
 import codeql.swift.elements.expr.NilLiteralExpr
-import codeql.swift.elements.expr.NumberLiteralExpr
-import codeql.swift.elements.expr.ObjCSelectorExpr
 import codeql.swift.elements.expr.ObjectLiteralExpr
-import codeql.swift.elements.expr.OneWayExpr
-import codeql.swift.elements.expr.OpaqueValueExpr
-import codeql.swift.elements.expr.OpenExistentialExpr
-import codeql.swift.elements.expr.OptionalEvaluationExpr
 import codeql.swift.elements.expr.OptionalTryExpr
-import codeql.swift.elements.expr.OtherConstructorDeclRefExpr
-import codeql.swift.elements.expr.OverloadSetRefExpr
+import codeql.swift.elements.type.OptionalType
 import codeql.swift.elements.expr.OverloadedDeclRefExpr
 import codeql.swift.elements.expr.ParenExpr
 import codeql.swift.elements.expr.PointerToPointerExpr
+import codeql.swift.elements.decl.PostfixOperatorDecl
 import codeql.swift.elements.expr.PostfixUnaryExpr
+import codeql.swift.elements.decl.PrefixOperatorDecl
 import codeql.swift.elements.expr.PrefixUnaryExpr
-import codeql.swift.elements.expr.PropertyWrapperValuePlaceholderExpr
 import codeql.swift.elements.expr.ProtocolMetatypeToObjectExpr
-import codeql.swift.elements.expr.RebindSelfInConstructorExpr
+import codeql.swift.elements.type.ProtocolType
 import codeql.swift.elements.expr.RegexLiteralExpr
+import codeql.swift.elements.stmt.RepeatWhileStmt
 import codeql.swift.elements.expr.SelfApplyExpr
-import codeql.swift.elements.expr.SequenceExpr
-import codeql.swift.elements.expr.StringLiteralExpr
 import codeql.swift.elements.expr.StringToPointerExpr
+import codeql.swift.elements.type.StructType
 import codeql.swift.elements.expr.SubscriptExpr
-import codeql.swift.elements.expr.SuperRefExpr
-import codeql.swift.elements.expr.TapExpr
+import codeql.swift.elements.stmt.SwitchStmt
 import codeql.swift.elements.expr.TryExpr
-import codeql.swift.elements.expr.TupleElementExpr
-import codeql.swift.elements.expr.TupleExpr
-import codeql.swift.elements.expr.TypeExpr
+import codeql.swift.elements.decl.TypeDecl
 import codeql.swift.elements.expr.UnderlyingToOpaqueExpr
 import codeql.swift.elements.expr.UnevaluatedInstanceExpr
-import codeql.swift.elements.expr.UnresolvedDeclRefExpr
-import codeql.swift.elements.expr.UnresolvedDotExpr
 import codeql.swift.elements.expr.UnresolvedMemberChainResultExpr
-import codeql.swift.elements.expr.UnresolvedMemberExpr
-import codeql.swift.elements.expr.UnresolvedPatternExpr
-import codeql.swift.elements.expr.UnresolvedSpecializeExpr
 import codeql.swift.elements.expr.UnresolvedTypeConversionExpr
-import codeql.swift.elements.expr.VarargExpansionExpr
-import codeql.swift.elements.pattern.AnyPattern
-import codeql.swift.elements.pattern.BindingPattern
-import codeql.swift.elements.pattern.BoolPattern
-import codeql.swift.elements.pattern.EnumElementPattern
-import codeql.swift.elements.pattern.ExprPattern
-import codeql.swift.elements.pattern.IsPattern
-import codeql.swift.elements.pattern.NamedPattern
-import codeql.swift.elements.pattern.OptionalSomePattern
-import codeql.swift.elements.pattern.ParenPattern
-import codeql.swift.elements.pattern.Pattern
-import codeql.swift.elements.pattern.TuplePattern
-import codeql.swift.elements.pattern.TypedPattern
-import codeql.swift.elements.stmt.BraceStmt
-import codeql.swift.elements.stmt.BreakStmt
-import codeql.swift.elements.stmt.CaseLabelItem
-import codeql.swift.elements.stmt.CaseStmt
-import codeql.swift.elements.stmt.ConditionElement
-import codeql.swift.elements.stmt.ContinueStmt
-import codeql.swift.elements.stmt.DeferStmt
-import codeql.swift.elements.stmt.DoCatchStmt
-import codeql.swift.elements.stmt.DoStmt
-import codeql.swift.elements.stmt.FailStmt
-import codeql.swift.elements.stmt.FallthroughStmt
-import codeql.swift.elements.stmt.ForEachStmt
+import codeql.swift.elements.type.VariadicSequenceType
+import codeql.swift.elements.decl.AbstractTypeParamDecl
+import codeql.swift.elements.expr.BooleanLiteralExpr
+import codeql.swift.elements.expr.ConditionalCheckedCastExpr
+import codeql.swift.elements.decl.ConstructorDecl
+import codeql.swift.elements.expr.ConstructorRefCallExpr
+import codeql.swift.elements.decl.DestructorDecl
+import codeql.swift.elements.expr.DotSyntaxCallExpr
+import codeql.swift.elements.expr.DynamicMemberRefExpr
+import codeql.swift.elements.expr.DynamicSubscriptExpr
+import codeql.swift.elements.expr.ForcedCheckedCastExpr
+import codeql.swift.elements.decl.FuncDecl
+import codeql.swift.elements.decl.GenericTypeDecl
 import codeql.swift.elements.stmt.GuardStmt
 import codeql.swift.elements.stmt.IfStmt
-import codeql.swift.elements.stmt.LabeledConditionalStmt
-import codeql.swift.elements.stmt.LabeledStmt
-import codeql.swift.elements.stmt.PoundAssertStmt
-import codeql.swift.elements.stmt.RepeatWhileStmt
-import codeql.swift.elements.stmt.ReturnStmt
-import codeql.swift.elements.stmt.Stmt
-import codeql.swift.elements.stmt.StmtCondition
-import codeql.swift.elements.stmt.SwitchStmt
-import codeql.swift.elements.stmt.ThrowStmt
+import codeql.swift.elements.expr.IsExpr
+import codeql.swift.elements.expr.MagicIdentifierLiteralExpr
+import codeql.swift.elements.decl.ModuleDecl
+import codeql.swift.elements.expr.NumberLiteralExpr
+import codeql.swift.elements.expr.StringLiteralExpr
+import codeql.swift.elements.decl.SubscriptDecl
+import codeql.swift.elements.decl.VarDecl
 import codeql.swift.elements.stmt.WhileStmt
-import codeql.swift.elements.stmt.YieldStmt
-import codeql.swift.elements.type.AnyBuiltinIntegerType
-import codeql.swift.elements.type.AnyFunctionType
-import codeql.swift.elements.type.AnyGenericType
-import codeql.swift.elements.type.AnyMetatypeType
-import codeql.swift.elements.type.ArchetypeType
-import codeql.swift.elements.type.ArraySliceType
-import codeql.swift.elements.type.BoundGenericClassType
-import codeql.swift.elements.type.BoundGenericEnumType
-import codeql.swift.elements.type.BoundGenericStructType
-import codeql.swift.elements.type.BoundGenericType
-import codeql.swift.elements.type.BuiltinBridgeObjectType
-import codeql.swift.elements.type.BuiltinDefaultActorStorageType
-import codeql.swift.elements.type.BuiltinExecutorType
-import codeql.swift.elements.type.BuiltinFloatType
-import codeql.swift.elements.type.BuiltinIntegerLiteralType
-import codeql.swift.elements.type.BuiltinIntegerType
-import codeql.swift.elements.type.BuiltinJobType
-import codeql.swift.elements.type.BuiltinNativeObjectType
-import codeql.swift.elements.type.BuiltinRawPointerType
-import codeql.swift.elements.type.BuiltinRawUnsafeContinuationType
-import codeql.swift.elements.type.BuiltinType
-import codeql.swift.elements.type.BuiltinUnsafeValueBufferType
-import codeql.swift.elements.type.BuiltinVectorType
-import codeql.swift.elements.type.ClassType
-import codeql.swift.elements.type.DependentMemberType
-import codeql.swift.elements.type.DictionaryType
-import codeql.swift.elements.type.DynamicSelfType
-import codeql.swift.elements.type.EnumType
-import codeql.swift.elements.type.ErrorType
-import codeql.swift.elements.type.ExistentialMetatypeType
-import codeql.swift.elements.type.ExistentialType
-import codeql.swift.elements.type.FunctionType
-import codeql.swift.elements.type.GenericFunctionType
-import codeql.swift.elements.type.GenericTypeParamType
-import codeql.swift.elements.type.InOutType
-import codeql.swift.elements.type.LValueType
-import codeql.swift.elements.type.MetatypeType
-import codeql.swift.elements.type.ModuleType
-import codeql.swift.elements.type.NestedArchetypeType
-import codeql.swift.elements.type.NominalOrBoundGenericNominalType
-import codeql.swift.elements.type.NominalType
-import codeql.swift.elements.type.OpaqueTypeArchetypeType
-import codeql.swift.elements.type.OpenedArchetypeType
-import codeql.swift.elements.type.OptionalType
-import codeql.swift.elements.type.ParenType
-import codeql.swift.elements.type.PlaceholderType
-import codeql.swift.elements.type.PrimaryArchetypeType
-import codeql.swift.elements.type.ProtocolCompositionType
-import codeql.swift.elements.type.ProtocolType
-import codeql.swift.elements.type.ReferenceStorageType
-import codeql.swift.elements.type.SequenceArchetypeType
-import codeql.swift.elements.type.SilBlockStorageType
-import codeql.swift.elements.type.SilBoxType
-import codeql.swift.elements.type.SilFunctionType
-import codeql.swift.elements.type.SilTokenType
-import codeql.swift.elements.type.StructType
-import codeql.swift.elements.type.SubstitutableType
-import codeql.swift.elements.type.SugarType
-import codeql.swift.elements.type.SyntaxSugarType
-import codeql.swift.elements.type.TupleType
-import codeql.swift.elements.type.Type
-import codeql.swift.elements.type.TypeAliasType
-import codeql.swift.elements.type.TypeRepr
-import codeql.swift.elements.type.TypeVariableType
-import codeql.swift.elements.type.UnarySyntaxSugarType
-import codeql.swift.elements.type.UnboundGenericType
-import codeql.swift.elements.type.UnmanagedStorageType
-import codeql.swift.elements.type.UnownedStorageType
-import codeql.swift.elements.type.UnresolvedType
-import codeql.swift.elements.type.VariadicSequenceType
-import codeql.swift.elements.type.WeakStorageType
+import codeql.swift.elements.decl.AccessorDecl
+import codeql.swift.elements.decl.AssociatedTypeDecl
+import codeql.swift.elements.decl.ConcreteFuncDecl
+import codeql.swift.elements.decl.ConcreteVarDecl
+import codeql.swift.elements.expr.FloatLiteralExpr
+import codeql.swift.elements.decl.GenericTypeParamDecl
+import codeql.swift.elements.expr.IntegerLiteralExpr
+import codeql.swift.elements.decl.NominalTypeDecl
+import codeql.swift.elements.decl.OpaqueTypeDecl
+import codeql.swift.elements.decl.ParamDecl
+import codeql.swift.elements.decl.TypeAliasDecl
+import codeql.swift.elements.decl.ClassDecl
+import codeql.swift.elements.decl.EnumDecl
+import codeql.swift.elements.decl.ProtocolDecl
+import codeql.swift.elements.decl.StructDecl
--- a/swift/ql/lib/codeql/swift/elements/DbFile.qll
+++ b/swift/ql/lib/codeql/swift/elements/DbFile.qll
@@ -0,0 +1,4 @@
+// generated by codegen/codegen.py, remove this comment if you wish to edit this file
+private import codeql.swift.generated.DbFile
+
+class DbFile extends DbFileBase { }
--- a/swift/ql/lib/codeql/swift/elements/DbLocation.qll
+++ b/swift/ql/lib/codeql/swift/elements/DbLocation.qll
@@ -0,0 +1,4 @@
+// generated by codegen/codegen.py, remove this comment if you wish to edit this file
+private import codeql.swift.generated.DbLocation
+
+class DbLocation extends DbLocationBase { }
--- a/swift/ql/lib/codeql/swift/elements/File.qll
+++ b/swift/ql/lib/codeql/swift/elements/File.qll
@@ -4,9 +4,6 @@ class File extends FileBase {
  /** toString */
  override string toString() { result = getAbsolutePath() }

-  /** Gets the name of this file. */
-  override string getName() { files(this, result) }
-
  /** Gets the absolute path of this file. */
  string getAbsolutePath() { result = getName() }

--- a/swift/ql/lib/codeql/swift/elements/Locatable.qll
+++ b/swift/ql/lib/codeql/swift/elements/Locatable.qll
@@ -1,12 +1,13 @@
 private import codeql.swift.generated.Locatable
 private import codeql.swift.elements.File
+private import codeql.swift.elements.UnknownLocation

 class Locatable extends LocatableBase {
  pragma[nomagic]
-  override Location getLocation() {
-    result = LocatableBase.super.getLocation()
+  override Location getImmediateLocation() {
+    result = LocatableBase.super.getImmediateLocation()
    or
-    not exists(LocatableBase.super.getLocation()) and result instanceof UnknownLocation
+    not exists(LocatableBase.super.getImmediateLocation()) and result instanceof UnknownLocation
  }

  /**
--- a/swift/ql/lib/codeql/swift/elements/Location.qll
+++ b/swift/ql/lib/codeql/swift/elements/Location.qll
@@ -9,7 +9,3 @@ class Location extends LocationBase {
    ec = getEndColumn()
  }
 }
-
-class UnknownLocation extends Location {
-  UnknownLocation() { hasLocationInfo("", 0, 0, 0, 0) }
-}
--- a/swift/ql/lib/codeql/swift/elements/UnknownFile.qll
+++ b/swift/ql/lib/codeql/swift/elements/UnknownFile.qll
@@ -0,0 +1,5 @@
+private import codeql.swift.generated.UnknownFile
+
+class UnknownFile extends UnknownFileBase {
+  override string getName() { result = "" }
+}
--- a/swift/ql/lib/codeql/swift/elements/UnknownLocation.qll
+++ b/swift/ql/lib/codeql/swift/elements/UnknownLocation.qll
@@ -0,0 +1,14 @@
+private import codeql.swift.generated.UnknownLocation
+private import codeql.swift.elements.UnknownFile
+private import codeql.swift.elements.File
+
+class UnknownLocation extends UnknownLocationBase {
+  override File getImmediateFile() {
+    result instanceof UnknownFile
+  }
+
+  override int getStartLine() { result = 0 }
+  override int getStartColumn() { result = 0 }
+  override int getEndLine() { result = 0 }
+  override int getEndColumn() { result = 0 }
+}
--- a/swift/ql/lib/codeql/swift/elements/expr/ExplicitCastExpr.qll
+++ b/swift/ql/lib/codeql/swift/elements/expr/ExplicitCastExpr.qll
@@ -1,7 +1,7 @@
 private import codeql.swift.generated.expr.ExplicitCastExpr

 class ExplicitCastExpr extends ExplicitCastExprBase {
-  override predicate convertsFrom(Expr e) { explicit_cast_exprs(this, e) }
+  override predicate convertsFrom(Expr e) { e = getImmediateSubExpr() }

  override string toString() { result = "(" + this.getType() + ") ..." }
 }
--- a/swift/ql/lib/codeql/swift/elements/expr/IdentityExpr.qll
+++ b/swift/ql/lib/codeql/swift/elements/expr/IdentityExpr.qll
@@ -1,5 +1,5 @@
 private import codeql.swift.generated.expr.IdentityExpr

 class IdentityExpr extends IdentityExprBase {
-  override predicate convertsFrom(Expr e) { identity_exprs(this, e) }
+  override predicate convertsFrom(Expr e) { e = getImmediateSubExpr() }
 }
--- a/swift/ql/lib/codeql/swift/elements/expr/ImplicitConversionExpr.qll
+++ b/swift/ql/lib/codeql/swift/elements/expr/ImplicitConversionExpr.qll
@@ -1,7 +1,7 @@
 private import codeql.swift.generated.expr.ImplicitConversionExpr

 class ImplicitConversionExpr extends ImplicitConversionExprBase {
-  override predicate convertsFrom(Expr e) { implicit_conversion_exprs(this, e) }
+  override predicate convertsFrom(Expr e) { e = getImmediateSubExpr() }

  override string toString() { result = "(" + this.getType().toString() + ") ..." }
 }
--- a/swift/ql/lib/codeql/swift/elements/expr/MethodCallExpr.qll
+++ b/swift/ql/lib/codeql/swift/elements/expr/MethodCallExpr.qll
@@ -1,4 +0,0 @@
-// generated by codegen/codegen.py, remove this comment if you wish to edit this file
-private import codeql.swift.generated.expr.MethodCallExpr
-
-class MethodCallExpr extends MethodCallExprBase { }
--- a/swift/ql/lib/codeql/swift/elements/expr/OneWayExpr.qll
+++ b/swift/ql/lib/codeql/swift/elements/expr/OneWayExpr.qll
@@ -1,7 +1,7 @@
 private import codeql.swift.generated.expr.OneWayExpr

 class OneWayExpr extends OneWayExprBase {
-  override predicate convertsFrom(Expr e) { one_way_exprs(this, e) }
+  override predicate convertsFrom(Expr e) { e = getImmediateSubExpr() }

  override string toString() { result = this.getSubExpr().toString() }
 }
--- a/swift/ql/lib/codeql/swift/elements/pattern/ParenPattern.qll
+++ b/swift/ql/lib/codeql/swift/elements/pattern/ParenPattern.qll
@@ -1,7 +1,7 @@
 private import codeql.swift.generated.pattern.ParenPattern

 class ParenPattern extends ParenPatternBase {
-  final override Pattern getResolveStep() { paren_patterns(this, result) }
+  final override Pattern getResolveStep() { result = getImmediateSubPattern() }

  override string toString() { result = "(...)" }
 }
--- a/swift/ql/lib/codeql/swift/elements/type/ArchetypeType.qll
+++ b/swift/ql/lib/codeql/swift/elements/type/ArchetypeType.qll
@@ -1,6 +1,4 @@
+// generated by codegen/codegen.py, remove this comment if you wish to edit this file
 private import codeql.swift.generated.type.ArchetypeType
-private import codeql.swift.elements.type.ClassType

-class ArchetypeType extends ArchetypeTypeBase {
-  override ClassType getSuperclass() { result = super.getSuperclass() }
-}
+class ArchetypeType extends ArchetypeTypeBase { }
--- a/swift/ql/lib/codeql/swift/generated/AstNode.qll
+++ b/swift/ql/lib/codeql/swift/generated/AstNode.qll
@@ -1,4 +1,6 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Locatable

-class AstNodeBase extends @ast_node, Locatable { }
+class AstNodeBase extends Cached::TAstNode, Locatable { }
--- a/swift/ql/lib/codeql/swift/generated/Callable.qll
+++ b/swift/ql/lib/codeql/swift/generated/Callable.qll
@@ -1,26 +1,26 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.stmt.BraceStmt
 import codeql.swift.elements.Element
 import codeql.swift.elements.decl.ParamDecl

-class CallableBase extends @callable, Element {
-  ParamDecl getParam(int index) {
-    exists(ParamDecl x |
-      callable_params(this, index, x) and
-      result = x.resolve()
-    )
+class CallableBase extends Cached::TCallable, Element {
+  ParamDecl getImmediateParam(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::Callable).getParam(index))
  }

-  ParamDecl getAParam() { result = getParam(_) }
+  final ParamDecl getParam(int index) { result = getImmediateParam(index).resolve() }

-  int getNumberOfParams() { result = count(getAParam()) }
+  final ParamDecl getAParam() { result = getParam(_) }

-  BraceStmt getBody() {
-    exists(BraceStmt x |
-      callable_bodies(this, x) and
-      result = x.resolve()
-    )
+  final int getNumberOfParams() { result = count(getAParam()) }
+
+  BraceStmt getImmediateBody() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::Callable).getBody())
  }

-  predicate hasBody() { exists(getBody()) }
+  final BraceStmt getBody() { result = getImmediateBody().resolve() }
+
+  final predicate hasBody() { exists(getBody()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/Db.qll
+++ b/swift/ql/lib/codeql/swift/generated/Db.qll
--- a/swift/ql/lib/codeql/swift/generated/DbFile.qll
+++ b/swift/ql/lib/codeql/swift/generated/DbFile.qll
@@ -0,0 +1,10 @@
+// generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
+import codeql.swift.elements.File
+
+class DbFileBase extends Cached::TDbFile, File {
+  final override Db::DbFile asDbInstance() { this = Cached::TDbFile(result) }
+
+  override string getAPrimaryQlClass() { result = "DbFile" }
+}
--- a/swift/ql/lib/codeql/swift/generated/DbLocation.qll
+++ b/swift/ql/lib/codeql/swift/generated/DbLocation.qll
@@ -0,0 +1,10 @@
+// generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
+import codeql.swift.elements.Location
+
+class DbLocationBase extends Cached::TDbLocation, Location {
+  final override Db::DbLocation asDbInstance() { this = Cached::TDbLocation(result) }
+
+  override string getAPrimaryQlClass() { result = "DbLocation" }
+}
--- a/swift/ql/lib/codeql/swift/generated/Element.qll
+++ b/swift/ql/lib/codeql/swift/generated/Element.qll
@@ -1,5 +1,8 @@
 // generated by codegen/codegen.py
-class ElementBase extends @element {
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
+
+class ElementBase extends Cached::TElement {
  string toString() { none() } // overridden by subclasses

  string getAPrimaryQlClass() { none() } // overridden by subclasses
@@ -14,5 +17,7 @@ class ElementBase extends @element {
    result = getResolveStep().resolve()
  }

-  predicate isUnknown() { element_is_unknown(this) }
+  Db::Element asDbInstance() { none() }
+
+  predicate isUnknown() { asDbInstance().(Db::Element).isUnknown() }
 }
--- a/swift/ql/lib/codeql/swift/generated/File.qll
+++ b/swift/ql/lib/codeql/swift/generated/File.qll
@@ -1,8 +1,8 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Element

-class FileBase extends @file, Element {
-  override string getAPrimaryQlClass() { result = "File" }
-
-  string getName() { files(this, result) }
+class FileBase extends Cached::TFile, Element {
+  string getName() { result = asDbInstance().(Db::File).getName() }
 }
--- a/swift/ql/lib/codeql/swift/generated/GetImmediateParent.qll
+++ b/swift/ql/lib/codeql/swift/generated/GetImmediateParent.qll
@@ -1,5 +1,5 @@
 // generated by codegen/codegen.py
-import codeql.swift.elements.Element
+import codeql.swift.elements

 /**
 * Gets any of the "immediate" children of `e`. "Immediate" means not taking into account node resolution: for example
@@ -10,227 +10,220 @@ import codeql.swift.elements.Element
 cached
 Element getAnImmediateChild(Element e) {
  // why does this look more complicated than it should?
-  // * `exists` and the `x` variable are there to reuse the same generation done in classes (where `x` is used to hide
-  //   nodes via resolution)
  // * none() simplifies generation, as we can append `or ...` without a special case for the first item
-  exists(Element x |
-    result = x and
-    (
-      none()
-      or
-      callable_params(e, _, x)
-      or
-      callable_bodies(e, x)
-      or
-      abstract_storage_decl_accessor_decls(e, _, x)
-      or
-      enum_case_decl_elements(e, _, x)
-      or
-      enum_element_decl_params(e, _, x)
-      or
-      if_config_clause_conditions(e, x)
-      or
-      if_config_clause_elements(e, _, x)
-      or
-      if_config_decl_clauses(e, _, x)
-      or
-      pattern_binding_decl_inits(e, _, x)
-      or
-      pattern_binding_decl_patterns(e, _, x)
-      or
-      subscript_decl_params(e, _, x)
-      or
-      top_level_code_decls(e, x)
-      or
-      any_try_exprs(e, x)
-      or
-      apply_exprs(e, x)
-      or
-      apply_expr_arguments(e, _, x)
-      or
-      arguments(e, _, x)
-      or
-      array_expr_elements(e, _, x)
-      or
-      assign_exprs(e, x, _)
-      or
-      assign_exprs(e, _, x)
-      or
-      bind_optional_exprs(e, x)
-      or
-      capture_list_expr_binding_decls(e, _, x)
-      or
-      capture_list_exprs(e, x)
-      or
-      dictionary_expr_elements(e, _, x)
-      or
-      dot_syntax_base_ignored_exprs(e, x, _)
-      or
-      dot_syntax_base_ignored_exprs(e, _, x)
-      or
-      dynamic_type_exprs(e, x)
-      or
-      enum_is_case_exprs(e, x, _)
-      or
-      enum_is_case_exprs(e, _, x)
-      or
-      explicit_cast_exprs(e, x)
-      or
-      force_value_exprs(e, x)
-      or
-      identity_exprs(e, x)
-      or
-      if_exprs(e, x, _, _)
-      or
-      if_exprs(e, _, x, _)
-      or
-      if_exprs(e, _, _, x)
-      or
-      implicit_conversion_exprs(e, x)
-      or
-      in_out_exprs(e, x)
-      or
-      interpolated_string_literal_expr_interpolation_count_exprs(e, x)
-      or
-      interpolated_string_literal_expr_literal_capacity_exprs(e, x)
-      or
-      interpolated_string_literal_expr_appending_exprs(e, x)
-      or
-      key_path_application_exprs(e, x, _)
-      or
-      key_path_application_exprs(e, _, x)
-      or
-      key_path_expr_roots(e, x)
-      or
-      key_path_expr_parsed_paths(e, x)
-      or
-      lazy_initializer_exprs(e, x)
-      or
-      lookup_exprs(e, x)
-      or
-      make_temporarily_escapable_exprs(e, x, _, _)
-      or
-      make_temporarily_escapable_exprs(e, _, x, _)
-      or
-      make_temporarily_escapable_exprs(e, _, _, x)
-      or
-      obj_c_selector_exprs(e, x, _)
-      or
-      one_way_exprs(e, x)
-      or
-      open_existential_exprs(e, x, _, _)
-      or
-      open_existential_exprs(e, _, x, _)
-      or
-      open_existential_exprs(e, _, _, x)
-      or
-      optional_evaluation_exprs(e, x)
-      or
-      rebind_self_in_constructor_exprs(e, x, _)
-      or
-      rebind_self_in_constructor_exprs(e, _, x)
-      or
-      self_apply_exprs(e, x)
-      or
-      sequence_expr_elements(e, _, x)
-      or
-      subscript_expr_arguments(e, _, x)
-      or
-      tap_expr_sub_exprs(e, x)
-      or
-      tap_exprs(e, x, _)
-      or
-      tuple_element_exprs(e, x, _)
-      or
-      tuple_expr_elements(e, _, x)
-      or
-      type_expr_type_reprs(e, x)
-      or
-      unresolved_dot_exprs(e, x, _)
-      or
-      unresolved_pattern_exprs(e, x)
-      or
-      vararg_expansion_exprs(e, x)
-      or
-      binding_patterns(e, x)
-      or
-      enum_element_pattern_sub_patterns(e, x)
-      or
-      expr_patterns(e, x)
-      or
-      is_pattern_cast_type_reprs(e, x)
-      or
-      is_pattern_sub_patterns(e, x)
-      or
-      optional_some_patterns(e, x)
-      or
-      paren_patterns(e, x)
-      or
-      tuple_pattern_elements(e, _, x)
-      or
-      typed_patterns(e, x)
-      or
-      typed_pattern_type_reprs(e, x)
-      or
-      brace_stmt_elements(e, _, x)
-      or
-      case_label_items(e, x)
-      or
-      case_label_item_guards(e, x)
-      or
-      case_stmts(e, x)
-      or
-      case_stmt_labels(e, _, x)
-      or
-      condition_element_booleans(e, x)
-      or
-      condition_element_patterns(e, x)
-      or
-      condition_element_initializers(e, x)
-      or
-      defer_stmts(e, x)
-      or
-      do_catch_stmts(e, x)
-      or
-      do_catch_stmt_catches(e, _, x)
-      or
-      do_stmts(e, x)
-      or
-      for_each_stmts(e, x, _, _)
-      or
-      for_each_stmts(e, _, x, _)
-      or
-      for_each_stmt_wheres(e, x)
-      or
-      for_each_stmts(e, _, _, x)
-      or
-      guard_stmts(e, x)
-      or
-      if_stmts(e, x)
-      or
-      if_stmt_elses(e, x)
-      or
-      labeled_conditional_stmts(e, x)
-      or
-      repeat_while_stmts(e, x, _)
-      or
-      repeat_while_stmts(e, _, x)
-      or
-      return_stmt_results(e, x)
-      or
-      stmt_condition_elements(e, _, x)
-      or
-      switch_stmts(e, x)
-      or
-      switch_stmt_cases(e, _, x)
-      or
-      throw_stmts(e, x)
-      or
-      while_stmts(e, x)
-      or
-      yield_stmt_results(e, _, x)
-    )
-  )
+  none()
+  or
+  result = e.(Callable).getImmediateParam(_)
+  or
+  result = e.(Callable).getImmediateBody()
+  or
+  result = e.(Argument).getImmediateExpr()
+  or
+  result = e.(ConditionElement).getImmediateBoolean()
+  or
+  result = e.(ConditionElement).getImmediatePattern()
+  or
+  result = e.(ConditionElement).getImmediateInitializer()
+  or
+  result = e.(IfConfigClause).getImmediateCondition()
+  or
+  result = e.(IfConfigClause).getImmediateElement(_)
+  or
+  result = e.(CaseLabelItem).getImmediatePattern()
+  or
+  result = e.(CaseLabelItem).getImmediateGuard()
+  or
+  result = e.(StmtCondition).getImmediateElement(_)
+  or
+  result = e.(AnyTryExpr).getImmediateSubExpr()
+  or
+  result = e.(ApplyExpr).getImmediateFunction()
+  or
+  result = e.(ApplyExpr).getImmediateArgument(_)
+  or
+  result = e.(AssignExpr).getImmediateDest()
+  or
+  result = e.(AssignExpr).getImmediateSource()
+  or
+  result = e.(BindOptionalExpr).getImmediateSubExpr()
+  or
+  result = e.(BindingPattern).getImmediateSubPattern()
+  or
+  result = e.(BraceStmt).getImmediateElement(_)
+  or
+  result = e.(CaptureListExpr).getImmediateBindingDecl(_)
+  or
+  result = e.(CaptureListExpr).getImmediateClosureBody()
+  or
+  result = e.(CaseStmt).getImmediateBody()
+  or
+  result = e.(CaseStmt).getImmediateLabel(_)
+  or
+  result = e.(DeferStmt).getImmediateBody()
+  or
+  result = e.(DotSyntaxBaseIgnoredExpr).getImmediateQualifier()
+  or
+  result = e.(DotSyntaxBaseIgnoredExpr).getImmediateSubExpr()
+  or
+  result = e.(DynamicTypeExpr).getImmediateBaseExpr()
+  or
+  result = e.(EnumCaseDecl).getImmediateElement(_)
+  or
+  result = e.(EnumElementPattern).getImmediateSubPattern()
+  or
+  result = e.(EnumIsCaseExpr).getImmediateSubExpr()
+  or
+  result = e.(EnumIsCaseExpr).getImmediateElement()
+  or
+  result = e.(ExplicitCastExpr).getImmediateSubExpr()
+  or
+  result = e.(ExprPattern).getImmediateSubExpr()
+  or
+  result = e.(ForceValueExpr).getImmediateSubExpr()
+  or
+  result = e.(IdentityExpr).getImmediateSubExpr()
+  or
+  result = e.(IfConfigDecl).getImmediateClause(_)
+  or
+  result = e.(IfExpr).getImmediateCondition()
+  or
+  result = e.(IfExpr).getImmediateThenExpr()
+  or
+  result = e.(IfExpr).getImmediateElseExpr()
+  or
+  result = e.(ImplicitConversionExpr).getImmediateSubExpr()
+  or
+  result = e.(InOutExpr).getImmediateSubExpr()
+  or
+  result = e.(IsPattern).getImmediateCastTypeRepr()
+  or
+  result = e.(IsPattern).getImmediateSubPattern()
+  or
+  result = e.(KeyPathApplicationExpr).getImmediateBase()
+  or
+  result = e.(KeyPathApplicationExpr).getImmediateKeyPath()
+  or
+  result = e.(KeyPathExpr).getImmediateRoot()
+  or
+  result = e.(KeyPathExpr).getImmediateParsedPath()
+  or
+  result = e.(LazyInitializerExpr).getImmediateSubExpr()
+  or
+  result = e.(LookupExpr).getImmediateBaseExpr()
+  or
+  result = e.(MakeTemporarilyEscapableExpr).getImmediateEscapingClosure()
+  or
+  result = e.(MakeTemporarilyEscapableExpr).getImmediateNonescapingClosure()
+  or
+  result = e.(MakeTemporarilyEscapableExpr).getImmediateSubExpr()
+  or
+  result = e.(ObjCSelectorExpr).getImmediateSubExpr()
+  or
+  result = e.(OneWayExpr).getImmediateSubExpr()
+  or
+  result = e.(OpenExistentialExpr).getImmediateSubExpr()
+  or
+  result = e.(OpenExistentialExpr).getImmediateExistential()
+  or
+  result = e.(OpenExistentialExpr).getImmediateOpaqueExpr()
+  or
+  result = e.(OptionalEvaluationExpr).getImmediateSubExpr()
+  or
+  result = e.(OptionalSomePattern).getImmediateSubPattern()
+  or
+  result = e.(ParenPattern).getImmediateSubPattern()
+  or
+  result = e.(PatternBindingDecl).getImmediateInit(_)
+  or
+  result = e.(PatternBindingDecl).getImmediatePattern(_)
+  or
+  result = e.(RebindSelfInConstructorExpr).getImmediateSubExpr()
+  or
+  result = e.(RebindSelfInConstructorExpr).getImmediateSelf()
+  or
+  result = e.(ReturnStmt).getImmediateResult()
+  or
+  result = e.(SequenceExpr).getImmediateElement(_)
+  or
+  result = e.(TapExpr).getImmediateSubExpr()
+  or
+  result = e.(TapExpr).getImmediateBody()
+  or
+  result = e.(ThrowStmt).getImmediateSubExpr()
+  or
+  result = e.(TopLevelCodeDecl).getImmediateBody()
+  or
+  result = e.(TupleElementExpr).getImmediateSubExpr()
+  or
+  result = e.(TupleExpr).getImmediateElement(_)
+  or
+  result = e.(TuplePattern).getImmediateElement(_)
+  or
+  result = e.(TypeExpr).getImmediateTypeRepr()
+  or
+  result = e.(TypedPattern).getImmediateSubPattern()
+  or
+  result = e.(TypedPattern).getImmediateTypeRepr()
+  or
+  result = e.(UnresolvedDotExpr).getImmediateBase()
+  or
+  result = e.(UnresolvedPatternExpr).getImmediateSubPattern()
+  or
+  result = e.(VarargExpansionExpr).getImmediateSubExpr()
+  or
+  result = e.(YieldStmt).getImmediateResult(_)
+  or
+  result = e.(AbstractStorageDecl).getImmediateAccessorDecl(_)
+  or
+  result = e.(ArrayExpr).getImmediateElement(_)
+  or
+  result = e.(DictionaryExpr).getImmediateElement(_)
+  or
+  result = e.(DoCatchStmt).getImmediateBody()
+  or
+  result = e.(DoCatchStmt).getImmediateCatch(_)
+  or
+  result = e.(DoStmt).getImmediateBody()
+  or
+  result = e.(EnumElementDecl).getImmediateParam(_)
+  or
+  result = e.(ForEachStmt).getImmediatePattern()
+  or
+  result = e.(ForEachStmt).getImmediateSequence()
+  or
+  result = e.(ForEachStmt).getImmediateWhere()
+  or
+  result = e.(ForEachStmt).getImmediateBody()
+  or
+  result = e.(InterpolatedStringLiteralExpr).getImmediateInterpolationCountExpr()
+  or
+  result = e.(InterpolatedStringLiteralExpr).getImmediateLiteralCapacityExpr()
+  or
+  result = e.(InterpolatedStringLiteralExpr).getImmediateAppendingExpr()
+  or
+  result = e.(LabeledConditionalStmt).getImmediateCondition()
+  or
+  result = e.(RepeatWhileStmt).getImmediateCondition()
+  or
+  result = e.(RepeatWhileStmt).getImmediateBody()
+  or
+  result = e.(SelfApplyExpr).getImmediateBaseExpr()
+  or
+  result = e.(SubscriptExpr).getImmediateArgument(_)
+  or
+  result = e.(SwitchStmt).getImmediateExpr()
+  or
+  result = e.(SwitchStmt).getImmediateCase(_)
+  or
+  result = e.(GuardStmt).getImmediateBody()
+  or
+  result = e.(IfStmt).getImmediateThen()
+  or
+  result = e.(IfStmt).getImmediateElse()
+  or
+  result = e.(SubscriptDecl).getImmediateParam(_)
+  or
+  result = e.(WhileStmt).getImmediateBody()
 }

 /**
--- a/swift/ql/lib/codeql/swift/generated/IpaConstructors.qll
+++ b/swift/ql/lib/codeql/swift/generated/IpaConstructors.qll
@@ -1,2 +1,2 @@
+
 // generated by codegen/codegen.py
-import codeql.swift.elements.expr.MethodCallExprConstructor
--- a/swift/ql/lib/codeql/swift/generated/IpaTypes.qll
+++ b/swift/ql/lib/codeql/swift/generated/IpaTypes.qll
--- a/swift/ql/lib/codeql/swift/generated/Locatable.qll
+++ b/swift/ql/lib/codeql/swift/generated/Locatable.qll
@@ -1,14 +1,15 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Element
 import codeql.swift.elements.Location

-class LocatableBase extends @locatable, Element {
-  Location getLocation() {
-    exists(Location x |
-      locatable_locations(this, x) and
-      result = x.resolve()
-    )
+class LocatableBase extends Cached::TLocatable, Element {
+  Location getImmediateLocation() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::Locatable).getLocation())
  }

-  predicate hasLocation() { exists(getLocation()) }
+  final Location getLocation() { result = getImmediateLocation().resolve() }
+
+  final predicate hasLocation() { exists(getLocation()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/Location.qll
+++ b/swift/ql/lib/codeql/swift/generated/Location.qll
@@ -1,22 +1,21 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Element
 import codeql.swift.elements.File

-class LocationBase extends @location, Element {
-  override string getAPrimaryQlClass() { result = "Location" }
-
-  File getFile() {
-    exists(File x |
-      locations(this, x, _, _, _, _) and
-      result = x.resolve()
-    )
+class LocationBase extends Cached::TLocation, Element {
+  File getImmediateFile() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::Location).getFile())
  }

-  int getStartLine() { locations(this, _, result, _, _, _) }
+  final File getFile() { result = getImmediateFile().resolve() }

-  int getStartColumn() { locations(this, _, _, result, _, _) }
+  int getStartLine() { result = asDbInstance().(Db::Location).getStartLine() }

-  int getEndLine() { locations(this, _, _, _, result, _) }
+  int getStartColumn() { result = asDbInstance().(Db::Location).getStartColumn() }

-  int getEndColumn() { locations(this, _, _, _, _, result) }
+  int getEndLine() { result = asDbInstance().(Db::Location).getEndLine() }
+
+  int getEndColumn() { result = asDbInstance().(Db::Location).getEndColumn() }
 }
--- a/swift/ql/lib/codeql/swift/generated/UnknownFile.qll
+++ b/swift/ql/lib/codeql/swift/generated/UnknownFile.qll
@@ -0,0 +1,8 @@
+// generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
+import codeql.swift.elements.File
+
+class UnknownFileBase extends Cached::TUnknownFile, File {
+  override string getAPrimaryQlClass() { result = "UnknownFile" }
+}
--- a/swift/ql/lib/codeql/swift/generated/UnknownLocation.qll
+++ b/swift/ql/lib/codeql/swift/generated/UnknownLocation.qll
@@ -0,0 +1,8 @@
+// generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
+import codeql.swift.elements.Location
+
+class UnknownLocationBase extends Cached::TUnknownLocation, Location {
+  override string getAPrimaryQlClass() { result = "UnknownLocation" }
+}
--- a/swift/ql/lib/codeql/swift/generated/decl/AbstractFunctionDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/AbstractFunctionDecl.qll
@@ -1,8 +1,11 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Callable
 import codeql.swift.elements.decl.GenericContext
 import codeql.swift.elements.decl.ValueDecl

-class AbstractFunctionDeclBase extends @abstract_function_decl, Callable, GenericContext, ValueDecl {
-  string getName() { abstract_function_decls(this, result) }
+class AbstractFunctionDeclBase extends Cached::TAbstractFunctionDecl, Callable, GenericContext,
+  ValueDecl {
+  string getName() { result = asDbInstance().(Db::AbstractFunctionDecl).getName() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/AbstractStorageDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/AbstractStorageDecl.qll
@@ -1,16 +1,19 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AccessorDecl
 import codeql.swift.elements.decl.ValueDecl

-class AbstractStorageDeclBase extends @abstract_storage_decl, ValueDecl {
-  AccessorDecl getAccessorDecl(int index) {
-    exists(AccessorDecl x |
-      abstract_storage_decl_accessor_decls(this, index, x) and
-      result = x.resolve()
-    )
+class AbstractStorageDeclBase extends Cached::TAbstractStorageDecl, ValueDecl {
+  AccessorDecl getImmediateAccessorDecl(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::AbstractStorageDecl).getAccessorDecl(index))
  }

-  AccessorDecl getAnAccessorDecl() { result = getAccessorDecl(_) }
+  final AccessorDecl getAccessorDecl(int index) {
+    result = getImmediateAccessorDecl(index).resolve()
+  }

-  int getNumberOfAccessorDecls() { result = count(getAnAccessorDecl()) }
+  final AccessorDecl getAnAccessorDecl() { result = getAccessorDecl(_) }
+
+  final int getNumberOfAccessorDecls() { result = count(getAnAccessorDecl()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/AbstractTypeParamDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/AbstractTypeParamDecl.qll
@@ -1,4 +1,6 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.TypeDecl

-class AbstractTypeParamDeclBase extends @abstract_type_param_decl, TypeDecl { }
+class AbstractTypeParamDeclBase extends Cached::TAbstractTypeParamDecl, TypeDecl { }
--- a/swift/ql/lib/codeql/swift/generated/decl/AccessorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/AccessorDecl.qll
@@ -1,14 +1,18 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.FuncDecl

-class AccessorDeclBase extends @accessor_decl, FuncDecl {
+class AccessorDeclBase extends Cached::TAccessorDecl, FuncDecl {
+  final override Db::AccessorDecl asDbInstance() { this = Cached::TAccessorDecl(result) }
+
  override string getAPrimaryQlClass() { result = "AccessorDecl" }

-  predicate isGetter() { accessor_decl_is_getter(this) }
+  predicate isGetter() { asDbInstance().(Db::AccessorDecl).isGetter() }

-  predicate isSetter() { accessor_decl_is_setter(this) }
+  predicate isSetter() { asDbInstance().(Db::AccessorDecl).isSetter() }

-  predicate isWillSet() { accessor_decl_is_will_set(this) }
+  predicate isWillSet() { asDbInstance().(Db::AccessorDecl).isWillSet() }

-  predicate isDidSet() { accessor_decl_is_did_set(this) }
+  predicate isDidSet() { asDbInstance().(Db::AccessorDecl).isDidSet() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/AssociatedTypeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/AssociatedTypeDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractTypeParamDecl

-class AssociatedTypeDeclBase extends @associated_type_decl, AbstractTypeParamDecl {
+class AssociatedTypeDeclBase extends Cached::TAssociatedTypeDecl, AbstractTypeParamDecl {
+  final override Db::AssociatedTypeDecl asDbInstance() {
+    this = Cached::TAssociatedTypeDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "AssociatedTypeDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ClassDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ClassDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.NominalTypeDecl

-class ClassDeclBase extends @class_decl, NominalTypeDecl {
+class ClassDeclBase extends Cached::TClassDecl, NominalTypeDecl {
+  final override Db::ClassDecl asDbInstance() { this = Cached::TClassDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ClassDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ConcreteFuncDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ConcreteFuncDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.FuncDecl

-class ConcreteFuncDeclBase extends @concrete_func_decl, FuncDecl {
+class ConcreteFuncDeclBase extends Cached::TConcreteFuncDecl, FuncDecl {
+  final override Db::ConcreteFuncDecl asDbInstance() { this = Cached::TConcreteFuncDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ConcreteFuncDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ConcreteVarDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ConcreteVarDecl.qll
@@ -1,8 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.VarDecl

-class ConcreteVarDeclBase extends @concrete_var_decl, VarDecl {
+class ConcreteVarDeclBase extends Cached::TConcreteVarDecl, VarDecl {
+  final override Db::ConcreteVarDecl asDbInstance() { this = Cached::TConcreteVarDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ConcreteVarDecl" }

-  int getIntroducerInt() { concrete_var_decls(this, result) }
+  int getIntroducerInt() { result = asDbInstance().(Db::ConcreteVarDecl).getIntroducerInt() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ConstructorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ConstructorDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractFunctionDecl

-class ConstructorDeclBase extends @constructor_decl, AbstractFunctionDecl {
+class ConstructorDeclBase extends Cached::TConstructorDecl, AbstractFunctionDecl {
+  final override Db::ConstructorDecl asDbInstance() { this = Cached::TConstructorDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ConstructorDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/Decl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/Decl.qll
@@ -1,4 +1,6 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.AstNode

-class DeclBase extends @decl, AstNode { }
+class DeclBase extends Cached::TDecl, AstNode { }
--- a/swift/ql/lib/codeql/swift/generated/decl/DestructorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/DestructorDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractFunctionDecl

-class DestructorDeclBase extends @destructor_decl, AbstractFunctionDecl {
+class DestructorDeclBase extends Cached::TDestructorDecl, AbstractFunctionDecl {
+  final override Db::DestructorDecl asDbInstance() { this = Cached::TDestructorDecl(result) }
+
  override string getAPrimaryQlClass() { result = "DestructorDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/EnumCaseDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/EnumCaseDecl.qll
@@ -1,18 +1,21 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.decl.EnumElementDecl

-class EnumCaseDeclBase extends @enum_case_decl, Decl {
+class EnumCaseDeclBase extends Cached::TEnumCaseDecl, Decl {
+  final override Db::EnumCaseDecl asDbInstance() { this = Cached::TEnumCaseDecl(result) }
+
  override string getAPrimaryQlClass() { result = "EnumCaseDecl" }

-  EnumElementDecl getElement(int index) {
-    exists(EnumElementDecl x |
-      enum_case_decl_elements(this, index, x) and
-      result = x.resolve()
-    )
+  EnumElementDecl getImmediateElement(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::EnumCaseDecl).getElement(index))
  }

-  EnumElementDecl getAnElement() { result = getElement(_) }
+  final EnumElementDecl getElement(int index) { result = getImmediateElement(index).resolve() }

-  int getNumberOfElements() { result = count(getAnElement()) }
+  final EnumElementDecl getAnElement() { result = getElement(_) }
+
+  final int getNumberOfElements() { result = count(getAnElement()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/EnumDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/EnumDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.NominalTypeDecl

-class EnumDeclBase extends @enum_decl, NominalTypeDecl {
+class EnumDeclBase extends Cached::TEnumDecl, NominalTypeDecl {
+  final override Db::EnumDecl asDbInstance() { this = Cached::TEnumDecl(result) }
+
  override string getAPrimaryQlClass() { result = "EnumDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/EnumElementDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/EnumElementDecl.qll
@@ -1,20 +1,23 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.ParamDecl
 import codeql.swift.elements.decl.ValueDecl

-class EnumElementDeclBase extends @enum_element_decl, ValueDecl {
+class EnumElementDeclBase extends Cached::TEnumElementDecl, ValueDecl {
+  final override Db::EnumElementDecl asDbInstance() { this = Cached::TEnumElementDecl(result) }
+
  override string getAPrimaryQlClass() { result = "EnumElementDecl" }

-  string getName() { enum_element_decls(this, result) }
+  string getName() { result = asDbInstance().(Db::EnumElementDecl).getName() }

-  ParamDecl getParam(int index) {
-    exists(ParamDecl x |
-      enum_element_decl_params(this, index, x) and
-      result = x.resolve()
-    )
+  ParamDecl getImmediateParam(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::EnumElementDecl).getParam(index))
  }

-  ParamDecl getAParam() { result = getParam(_) }
+  final ParamDecl getParam(int index) { result = getImmediateParam(index).resolve() }

-  int getNumberOfParams() { result = count(getAParam()) }
+  final ParamDecl getAParam() { result = getParam(_) }
+
+  final int getNumberOfParams() { result = count(getAParam()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ExtensionDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ExtensionDecl.qll
@@ -1,16 +1,19 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.decl.GenericContext
 import codeql.swift.elements.decl.IterableDeclContext
 import codeql.swift.elements.decl.NominalTypeDecl

-class ExtensionDeclBase extends @extension_decl, Decl, GenericContext, IterableDeclContext {
+class ExtensionDeclBase extends Cached::TExtensionDecl, Decl, GenericContext, IterableDeclContext {
+  final override Db::ExtensionDecl asDbInstance() { this = Cached::TExtensionDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ExtensionDecl" }

-  NominalTypeDecl getExtendedTypeDecl() {
-    exists(NominalTypeDecl x |
-      extension_decls(this, x) and
-      result = x.resolve()
-    )
+  NominalTypeDecl getImmediateExtendedTypeDecl() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ExtensionDecl).getExtendedTypeDecl())
  }
+
+  final NominalTypeDecl getExtendedTypeDecl() { result = getImmediateExtendedTypeDecl().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/FuncDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/FuncDecl.qll
@@ -1,4 +1,6 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractFunctionDecl

-class FuncDeclBase extends @func_decl, AbstractFunctionDecl { }
+class FuncDeclBase extends Cached::TFuncDecl, AbstractFunctionDecl { }
--- a/swift/ql/lib/codeql/swift/generated/decl/GenericContext.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/GenericContext.qll
@@ -1,16 +1,19 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Element
 import codeql.swift.elements.decl.GenericTypeParamDecl

-class GenericContextBase extends @generic_context, Element {
-  GenericTypeParamDecl getGenericTypeParam(int index) {
-    exists(GenericTypeParamDecl x |
-      generic_context_generic_type_params(this, index, x) and
-      result = x.resolve()
-    )
+class GenericContextBase extends Cached::TGenericContext, Element {
+  GenericTypeParamDecl getImmediateGenericTypeParam(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::GenericContext).getGenericTypeParam(index))
  }

-  GenericTypeParamDecl getAGenericTypeParam() { result = getGenericTypeParam(_) }
+  final GenericTypeParamDecl getGenericTypeParam(int index) {
+    result = getImmediateGenericTypeParam(index).resolve()
+  }

-  int getNumberOfGenericTypeParams() { result = count(getAGenericTypeParam()) }
+  final GenericTypeParamDecl getAGenericTypeParam() { result = getGenericTypeParam(_) }
+
+  final int getNumberOfGenericTypeParams() { result = count(getAGenericTypeParam()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/GenericTypeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/GenericTypeDecl.qll
@@ -1,5 +1,7 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.GenericContext
 import codeql.swift.elements.decl.TypeDecl

-class GenericTypeDeclBase extends @generic_type_decl, GenericContext, TypeDecl { }
+class GenericTypeDeclBase extends Cached::TGenericTypeDecl, GenericContext, TypeDecl { }
--- a/swift/ql/lib/codeql/swift/generated/decl/GenericTypeParamDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/GenericTypeParamDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractTypeParamDecl

-class GenericTypeParamDeclBase extends @generic_type_param_decl, AbstractTypeParamDecl {
+class GenericTypeParamDeclBase extends Cached::TGenericTypeParamDecl, AbstractTypeParamDecl {
+  final override Db::GenericTypeParamDecl asDbInstance() {
+    this = Cached::TGenericTypeParamDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "GenericTypeParamDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/IfConfigClause.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/IfConfigClause.qll
@@ -1,30 +1,32 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.AstNode
 import codeql.swift.elements.expr.Expr
 import codeql.swift.elements.Locatable

-class IfConfigClauseBase extends @if_config_clause, Locatable {
+class IfConfigClauseBase extends Cached::TIfConfigClause, Locatable {
+  final override Db::IfConfigClause asDbInstance() { this = Cached::TIfConfigClause(result) }
+
  override string getAPrimaryQlClass() { result = "IfConfigClause" }

-  Expr getCondition() {
-    exists(Expr x |
-      if_config_clause_conditions(this, x) and
-      result = x.resolve()
-    )
+  Expr getImmediateCondition() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::IfConfigClause).getCondition())
  }

-  predicate hasCondition() { exists(getCondition()) }
+  final Expr getCondition() { result = getImmediateCondition().resolve() }

-  AstNode getElement(int index) {
-    exists(AstNode x |
-      if_config_clause_elements(this, index, x) and
-      result = x.resolve()
-    )
+  final predicate hasCondition() { exists(getCondition()) }
+
+  AstNode getImmediateElement(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::IfConfigClause).getElement(index))
  }

-  AstNode getAnElement() { result = getElement(_) }
+  final AstNode getElement(int index) { result = getImmediateElement(index).resolve() }

-  int getNumberOfElements() { result = count(getAnElement()) }
+  final AstNode getAnElement() { result = getElement(_) }

-  predicate isActive() { if_config_clause_is_active(this) }
+  final int getNumberOfElements() { result = count(getAnElement()) }
+
+  predicate isActive() { asDbInstance().(Db::IfConfigClause).isActive() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/IfConfigDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/IfConfigDecl.qll
@@ -1,18 +1,21 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.decl.IfConfigClause

-class IfConfigDeclBase extends @if_config_decl, Decl {
+class IfConfigDeclBase extends Cached::TIfConfigDecl, Decl {
+  final override Db::IfConfigDecl asDbInstance() { this = Cached::TIfConfigDecl(result) }
+
  override string getAPrimaryQlClass() { result = "IfConfigDecl" }

-  IfConfigClause getClause(int index) {
-    exists(IfConfigClause x |
-      if_config_decl_clauses(this, index, x) and
-      result = x.resolve()
-    )
+  IfConfigClause getImmediateClause(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::IfConfigDecl).getClause(index))
  }

-  IfConfigClause getAClause() { result = getClause(_) }
+  final IfConfigClause getClause(int index) { result = getImmediateClause(index).resolve() }

-  int getNumberOfClauses() { result = count(getAClause()) }
+  final IfConfigClause getAClause() { result = getClause(_) }
+
+  final int getNumberOfClauses() { result = count(getAClause()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ImportDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ImportDecl.qll
@@ -1,28 +1,30 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.decl.ModuleDecl
 import codeql.swift.elements.decl.ValueDecl

-class ImportDeclBase extends @import_decl, Decl {
+class ImportDeclBase extends Cached::TImportDecl, Decl {
+  final override Db::ImportDecl asDbInstance() { this = Cached::TImportDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ImportDecl" }

-  predicate isExported() { import_decl_is_exported(this) }
+  predicate isExported() { asDbInstance().(Db::ImportDecl).isExported() }

-  ModuleDecl getModule() {
-    exists(ModuleDecl x |
-      import_decls(this, x) and
-      result = x.resolve()
-    )
+  ModuleDecl getImmediateModule() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ImportDecl).getModule())
  }

-  ValueDecl getDeclaration(int index) {
-    exists(ValueDecl x |
-      import_decl_declarations(this, index, x) and
-      result = x.resolve()
-    )
+  final ModuleDecl getModule() { result = getImmediateModule().resolve() }
+
+  ValueDecl getImmediateDeclaration(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ImportDecl).getDeclaration(index))
  }

-  ValueDecl getADeclaration() { result = getDeclaration(_) }
+  final ValueDecl getDeclaration(int index) { result = getImmediateDeclaration(index).resolve() }

-  int getNumberOfDeclarations() { result = count(getADeclaration()) }
+  final ValueDecl getADeclaration() { result = getDeclaration(_) }
+
+  final int getNumberOfDeclarations() { result = count(getADeclaration()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/InfixOperatorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/InfixOperatorDecl.qll
@@ -1,16 +1,21 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.OperatorDecl
 import codeql.swift.elements.decl.PrecedenceGroupDecl

-class InfixOperatorDeclBase extends @infix_operator_decl, OperatorDecl {
+class InfixOperatorDeclBase extends Cached::TInfixOperatorDecl, OperatorDecl {
+  final override Db::InfixOperatorDecl asDbInstance() { this = Cached::TInfixOperatorDecl(result) }
+
  override string getAPrimaryQlClass() { result = "InfixOperatorDecl" }

-  PrecedenceGroupDecl getPrecedenceGroup() {
-    exists(PrecedenceGroupDecl x |
-      infix_operator_decl_precedence_groups(this, x) and
-      result = x.resolve()
-    )
+  PrecedenceGroupDecl getImmediatePrecedenceGroup() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::InfixOperatorDecl).getPrecedenceGroup())
  }

-  predicate hasPrecedenceGroup() { exists(getPrecedenceGroup()) }
+  final PrecedenceGroupDecl getPrecedenceGroup() {
+    result = getImmediatePrecedenceGroup().resolve()
+  }
+
+  final predicate hasPrecedenceGroup() { exists(getPrecedenceGroup()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/IterableDeclContext.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/IterableDeclContext.qll
@@ -1,16 +1,17 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.Element

-class IterableDeclContextBase extends @iterable_decl_context, Element {
-  Decl getMember(int index) {
-    exists(Decl x |
-      iterable_decl_context_members(this, index, x) and
-      result = x.resolve()
-    )
+class IterableDeclContextBase extends Cached::TIterableDeclContext, Element {
+  Decl getImmediateMember(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::IterableDeclContext).getMember(index))
  }

-  Decl getAMember() { result = getMember(_) }
+  final Decl getMember(int index) { result = getImmediateMember(index).resolve() }

-  int getNumberOfMembers() { result = count(getAMember()) }
+  final Decl getAMember() { result = getMember(_) }
+
+  final int getNumberOfMembers() { result = count(getAMember()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/MissingMemberDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/MissingMemberDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl

-class MissingMemberDeclBase extends @missing_member_decl, Decl {
+class MissingMemberDeclBase extends Cached::TMissingMemberDecl, Decl {
+  final override Db::MissingMemberDecl asDbInstance() { this = Cached::TMissingMemberDecl(result) }
+
  override string getAPrimaryQlClass() { result = "MissingMemberDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ModuleDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ModuleDecl.qll
@@ -1,10 +1,14 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.TypeDecl

-class ModuleDeclBase extends @module_decl, TypeDecl {
+class ModuleDeclBase extends Cached::TModuleDecl, TypeDecl {
+  final override Db::ModuleDecl asDbInstance() { this = Cached::TModuleDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ModuleDecl" }

-  predicate isBuiltinModule() { module_decl_is_builtin_module(this) }
+  predicate isBuiltinModule() { asDbInstance().(Db::ModuleDecl).isBuiltinModule() }

-  predicate isSystemModule() { module_decl_is_system_module(this) }
+  predicate isSystemModule() { asDbInstance().(Db::ModuleDecl).isSystemModule() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/NominalTypeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/NominalTypeDecl.qll
@@ -1,13 +1,14 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.GenericTypeDecl
 import codeql.swift.elements.decl.IterableDeclContext
 import codeql.swift.elements.type.Type

-class NominalTypeDeclBase extends @nominal_type_decl, GenericTypeDecl, IterableDeclContext {
-  Type getType() {
-    exists(Type x |
-      nominal_type_decls(this, x) and
-      result = x.resolve()
-    )
+class NominalTypeDeclBase extends Cached::TNominalTypeDecl, GenericTypeDecl, IterableDeclContext {
+  Type getImmediateType() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::NominalTypeDecl).getType())
  }
+
+  final Type getType() { result = getImmediateType().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/OpaqueTypeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/OpaqueTypeDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.GenericTypeDecl

-class OpaqueTypeDeclBase extends @opaque_type_decl, GenericTypeDecl {
+class OpaqueTypeDeclBase extends Cached::TOpaqueTypeDecl, GenericTypeDecl {
+  final override Db::OpaqueTypeDecl asDbInstance() { this = Cached::TOpaqueTypeDecl(result) }
+
  override string getAPrimaryQlClass() { result = "OpaqueTypeDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/OperatorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/OperatorDecl.qll
@@ -1,6 +1,8 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl

-class OperatorDeclBase extends @operator_decl, Decl {
-  string getName() { operator_decls(this, result) }
+class OperatorDeclBase extends Cached::TOperatorDecl, Decl {
+  string getName() { result = asDbInstance().(Db::OperatorDecl).getName() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ParamDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ParamDecl.qll
@@ -1,8 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.VarDecl

-class ParamDeclBase extends @param_decl, VarDecl {
+class ParamDeclBase extends Cached::TParamDecl, VarDecl {
+  final override Db::ParamDecl asDbInstance() { this = Cached::TParamDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ParamDecl" }

-  predicate isInout() { param_decl_is_inout(this) }
+  predicate isInout() { asDbInstance().(Db::ParamDecl).isInout() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/PatternBindingDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/PatternBindingDecl.qll
@@ -1,30 +1,34 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.expr.Expr
 import codeql.swift.elements.pattern.Pattern

-class PatternBindingDeclBase extends @pattern_binding_decl, Decl {
+class PatternBindingDeclBase extends Cached::TPatternBindingDecl, Decl {
+  final override Db::PatternBindingDecl asDbInstance() {
+    this = Cached::TPatternBindingDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "PatternBindingDecl" }

-  Expr getInit(int index) {
-    exists(Expr x |
-      pattern_binding_decl_inits(this, index, x) and
-      result = x.resolve()
-    )
+  Expr getImmediateInit(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::PatternBindingDecl).getInit(index))
  }

-  predicate hasInit(int index) { exists(getInit(index)) }
+  final Expr getInit(int index) { result = getImmediateInit(index).resolve() }

-  Expr getAnInit() { result = getInit(_) }
+  final predicate hasInit(int index) { exists(getInit(index)) }

-  Pattern getPattern(int index) {
-    exists(Pattern x |
-      pattern_binding_decl_patterns(this, index, x) and
-      result = x.resolve()
-    )
+  final Expr getAnInit() { result = getInit(_) }
+
+  Pattern getImmediatePattern(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::PatternBindingDecl).getPattern(index))
  }

-  Pattern getAPattern() { result = getPattern(_) }
+  final Pattern getPattern(int index) { result = getImmediatePattern(index).resolve() }

-  int getNumberOfPatterns() { result = count(getAPattern()) }
+  final Pattern getAPattern() { result = getPattern(_) }
+
+  final int getNumberOfPatterns() { result = count(getAPattern()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/PostfixOperatorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/PostfixOperatorDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.OperatorDecl

-class PostfixOperatorDeclBase extends @postfix_operator_decl, OperatorDecl {
+class PostfixOperatorDeclBase extends Cached::TPostfixOperatorDecl, OperatorDecl {
+  final override Db::PostfixOperatorDecl asDbInstance() {
+    this = Cached::TPostfixOperatorDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "PostfixOperatorDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/PoundDiagnosticDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/PoundDiagnosticDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl

-class PoundDiagnosticDeclBase extends @pound_diagnostic_decl, Decl {
+class PoundDiagnosticDeclBase extends Cached::TPoundDiagnosticDecl, Decl {
+  final override Db::PoundDiagnosticDecl asDbInstance() {
+    this = Cached::TPoundDiagnosticDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "PoundDiagnosticDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/PrecedenceGroupDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/PrecedenceGroupDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl

-class PrecedenceGroupDeclBase extends @precedence_group_decl, Decl {
+class PrecedenceGroupDeclBase extends Cached::TPrecedenceGroupDecl, Decl {
+  final override Db::PrecedenceGroupDecl asDbInstance() {
+    this = Cached::TPrecedenceGroupDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "PrecedenceGroupDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/PrefixOperatorDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/PrefixOperatorDecl.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.OperatorDecl

-class PrefixOperatorDeclBase extends @prefix_operator_decl, OperatorDecl {
+class PrefixOperatorDeclBase extends Cached::TPrefixOperatorDecl, OperatorDecl {
+  final override Db::PrefixOperatorDecl asDbInstance() {
+    this = Cached::TPrefixOperatorDecl(result)
+  }
+
  override string getAPrimaryQlClass() { result = "PrefixOperatorDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ProtocolDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ProtocolDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.NominalTypeDecl

-class ProtocolDeclBase extends @protocol_decl, NominalTypeDecl {
+class ProtocolDeclBase extends Cached::TProtocolDecl, NominalTypeDecl {
+  final override Db::ProtocolDecl asDbInstance() { this = Cached::TProtocolDecl(result) }
+
  override string getAPrimaryQlClass() { result = "ProtocolDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/StructDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/StructDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.NominalTypeDecl

-class StructDeclBase extends @struct_decl, NominalTypeDecl {
+class StructDeclBase extends Cached::TStructDecl, NominalTypeDecl {
+  final override Db::StructDecl asDbInstance() { this = Cached::TStructDecl(result) }
+
  override string getAPrimaryQlClass() { result = "StructDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/SubscriptDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/SubscriptDecl.qll
@@ -1,27 +1,29 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractStorageDecl
 import codeql.swift.elements.decl.GenericContext
 import codeql.swift.elements.decl.ParamDecl
 import codeql.swift.elements.type.Type

-class SubscriptDeclBase extends @subscript_decl, AbstractStorageDecl, GenericContext {
+class SubscriptDeclBase extends Cached::TSubscriptDecl, AbstractStorageDecl, GenericContext {
+  final override Db::SubscriptDecl asDbInstance() { this = Cached::TSubscriptDecl(result) }
+
  override string getAPrimaryQlClass() { result = "SubscriptDecl" }

-  ParamDecl getParam(int index) {
-    exists(ParamDecl x |
-      subscript_decl_params(this, index, x) and
-      result = x.resolve()
-    )
+  ParamDecl getImmediateParam(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::SubscriptDecl).getParam(index))
  }

-  ParamDecl getAParam() { result = getParam(_) }
+  final ParamDecl getParam(int index) { result = getImmediateParam(index).resolve() }

-  int getNumberOfParams() { result = count(getAParam()) }
+  final ParamDecl getAParam() { result = getParam(_) }

-  Type getElementType() {
-    exists(Type x |
-      subscript_decls(this, x) and
-      result = x.resolve()
-    )
+  final int getNumberOfParams() { result = count(getAParam()) }
+
+  Type getImmediateElementType() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::SubscriptDecl).getElementType())
  }
+
+  final Type getElementType() { result = getImmediateElementType().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/TopLevelCodeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/TopLevelCodeDecl.qll
@@ -1,14 +1,17 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.stmt.BraceStmt
 import codeql.swift.elements.decl.Decl

-class TopLevelCodeDeclBase extends @top_level_code_decl, Decl {
+class TopLevelCodeDeclBase extends Cached::TTopLevelCodeDecl, Decl {
+  final override Db::TopLevelCodeDecl asDbInstance() { this = Cached::TTopLevelCodeDecl(result) }
+
  override string getAPrimaryQlClass() { result = "TopLevelCodeDecl" }

-  BraceStmt getBody() {
-    exists(BraceStmt x |
-      top_level_code_decls(this, x) and
-      result = x.resolve()
-    )
+  BraceStmt getImmediateBody() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::TopLevelCodeDecl).getBody())
  }
+
+  final BraceStmt getBody() { result = getImmediateBody().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/TypeAliasDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/TypeAliasDecl.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.GenericTypeDecl

-class TypeAliasDeclBase extends @type_alias_decl, GenericTypeDecl {
+class TypeAliasDeclBase extends Cached::TTypeAliasDecl, GenericTypeDecl {
+  final override Db::TypeAliasDecl asDbInstance() { this = Cached::TTypeAliasDecl(result) }
+
  override string getAPrimaryQlClass() { result = "TypeAliasDecl" }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/TypeDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/TypeDecl.qll
@@ -1,18 +1,19 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.type.Type
 import codeql.swift.elements.decl.ValueDecl

-class TypeDeclBase extends @type_decl, ValueDecl {
-  string getName() { type_decls(this, result) }
+class TypeDeclBase extends Cached::TTypeDecl, ValueDecl {
+  string getName() { result = asDbInstance().(Db::TypeDecl).getName() }

-  Type getBaseType(int index) {
-    exists(Type x |
-      type_decl_base_types(this, index, x) and
-      result = x.resolve()
-    )
+  Type getImmediateBaseType(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::TypeDecl).getBaseType(index))
  }

-  Type getABaseType() { result = getBaseType(_) }
+  final Type getBaseType(int index) { result = getImmediateBaseType(index).resolve() }

-  int getNumberOfBaseTypes() { result = count(getABaseType()) }
+  final Type getABaseType() { result = getBaseType(_) }
+
+  final int getNumberOfBaseTypes() { result = count(getABaseType()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/ValueDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/ValueDecl.qll
@@ -1,12 +1,13 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.Decl
 import codeql.swift.elements.type.Type

-class ValueDeclBase extends @value_decl, Decl {
-  Type getInterfaceType() {
-    exists(Type x |
-      value_decls(this, x) and
-      result = x.resolve()
-    )
+class ValueDeclBase extends Cached::TValueDecl, Decl {
+  Type getImmediateInterfaceType() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ValueDecl).getInterfaceType())
  }
+
+  final Type getInterfaceType() { result = getImmediateInterfaceType().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/decl/VarDecl.qll
+++ b/swift/ql/lib/codeql/swift/generated/decl/VarDecl.qll
@@ -1,43 +1,43 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.decl.AbstractStorageDecl
 import codeql.swift.elements.expr.Expr
 import codeql.swift.elements.pattern.Pattern
 import codeql.swift.elements.type.Type

-class VarDeclBase extends @var_decl, AbstractStorageDecl {
-  string getName() { var_decls(this, result, _) }
+class VarDeclBase extends Cached::TVarDecl, AbstractStorageDecl {
+  string getName() { result = asDbInstance().(Db::VarDecl).getName() }

-  Type getType() {
-    exists(Type x |
-      var_decls(this, _, x) and
-      result = x.resolve()
-    )
+  Type getImmediateType() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::VarDecl).getType())
  }

-  Type getAttachedPropertyWrapperType() {
-    exists(Type x |
-      var_decl_attached_property_wrapper_types(this, x) and
-      result = x.resolve()
-    )
+  final Type getType() { result = getImmediateType().resolve() }
+
+  Type getImmediateAttachedPropertyWrapperType() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::VarDecl).getAttachedPropertyWrapperType())
  }

-  predicate hasAttachedPropertyWrapperType() { exists(getAttachedPropertyWrapperType()) }
-
-  Pattern getParentPattern() {
-    exists(Pattern x |
-      var_decl_parent_patterns(this, x) and
-      result = x.resolve()
-    )
+  final Type getAttachedPropertyWrapperType() {
+    result = getImmediateAttachedPropertyWrapperType().resolve()
  }

-  predicate hasParentPattern() { exists(getParentPattern()) }
+  final predicate hasAttachedPropertyWrapperType() { exists(getAttachedPropertyWrapperType()) }

-  Expr getParentInitializer() {
-    exists(Expr x |
-      var_decl_parent_initializers(this, x) and
-      result = x.resolve()
-    )
+  Pattern getImmediateParentPattern() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::VarDecl).getParentPattern())
  }

-  predicate hasParentInitializer() { exists(getParentInitializer()) }
+  final Pattern getParentPattern() { result = getImmediateParentPattern().resolve() }
+
+  final predicate hasParentPattern() { exists(getParentPattern()) }
+
+  Expr getImmediateParentInitializer() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::VarDecl).getParentInitializer())
+  }
+
+  final Expr getParentInitializer() { result = getImmediateParentInitializer().resolve() }
+
+  final predicate hasParentInitializer() { exists(getParentInitializer()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/AbstractClosureExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/AbstractClosureExpr.qll
@@ -1,5 +1,7 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.Callable
 import codeql.swift.elements.expr.Expr

-class AbstractClosureExprBase extends @abstract_closure_expr, Callable, Expr { }
+class AbstractClosureExprBase extends Cached::TAbstractClosureExpr, Callable, Expr { }
--- a/swift/ql/lib/codeql/swift/generated/expr/AnyHashableErasureExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/AnyHashableErasureExpr.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.ImplicitConversionExpr

-class AnyHashableErasureExprBase extends @any_hashable_erasure_expr, ImplicitConversionExpr {
+class AnyHashableErasureExprBase extends Cached::TAnyHashableErasureExpr, ImplicitConversionExpr {
+  final override Db::AnyHashableErasureExpr asDbInstance() {
+    this = Cached::TAnyHashableErasureExpr(result)
+  }
+
  override string getAPrimaryQlClass() { result = "AnyHashableErasureExpr" }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/AnyTryExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/AnyTryExpr.qll
@@ -1,11 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.Expr

-class AnyTryExprBase extends @any_try_expr, Expr {
-  Expr getSubExpr() {
-    exists(Expr x |
-      any_try_exprs(this, x) and
-      result = x.resolve()
-    )
+class AnyTryExprBase extends Cached::TAnyTryExpr, Expr {
+  Expr getImmediateSubExpr() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::AnyTryExpr).getSubExpr())
  }
+
+  final Expr getSubExpr() { result = getImmediateSubExpr().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/AppliedPropertyWrapperExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/AppliedPropertyWrapperExpr.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.Expr

-class AppliedPropertyWrapperExprBase extends @applied_property_wrapper_expr, Expr {
+class AppliedPropertyWrapperExprBase extends Cached::TAppliedPropertyWrapperExpr, Expr {
+  final override Db::AppliedPropertyWrapperExpr asDbInstance() {
+    this = Cached::TAppliedPropertyWrapperExpr(result)
+  }
+
  override string getAPrimaryQlClass() { result = "AppliedPropertyWrapperExpr" }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/ApplyExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/ApplyExpr.qll
@@ -1,23 +1,23 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.Argument
 import codeql.swift.elements.expr.Expr

-class ApplyExprBase extends @apply_expr, Expr {
-  Expr getFunction() {
-    exists(Expr x |
-      apply_exprs(this, x) and
-      result = x.resolve()
-    )
+class ApplyExprBase extends Cached::TApplyExpr, Expr {
+  Expr getImmediateFunction() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ApplyExpr).getFunction())
  }

-  Argument getArgument(int index) {
-    exists(Argument x |
-      apply_expr_arguments(this, index, x) and
-      result = x.resolve()
-    )
+  final Expr getFunction() { result = getImmediateFunction().resolve() }
+
+  Argument getImmediateArgument(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ApplyExpr).getArgument(index))
  }

-  Argument getAnArgument() { result = getArgument(_) }
+  final Argument getArgument(int index) { result = getImmediateArgument(index).resolve() }

-  int getNumberOfArguments() { result = count(getAnArgument()) }
+  final Argument getAnArgument() { result = getArgument(_) }
+
+  final int getNumberOfArguments() { result = count(getAnArgument()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/ArchetypeToSuperExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/ArchetypeToSuperExpr.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.ImplicitConversionExpr

-class ArchetypeToSuperExprBase extends @archetype_to_super_expr, ImplicitConversionExpr {
+class ArchetypeToSuperExprBase extends Cached::TArchetypeToSuperExpr, ImplicitConversionExpr {
+  final override Db::ArchetypeToSuperExpr asDbInstance() {
+    this = Cached::TArchetypeToSuperExpr(result)
+  }
+
  override string getAPrimaryQlClass() { result = "ArchetypeToSuperExpr" }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/Argument.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/Argument.qll
@@ -1,16 +1,19 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.Expr
 import codeql.swift.elements.Locatable

-class ArgumentBase extends @argument, Locatable {
+class ArgumentBase extends Cached::TArgument, Locatable {
+  final override Db::Argument asDbInstance() { this = Cached::TArgument(result) }
+
  override string getAPrimaryQlClass() { result = "Argument" }

-  string getLabel() { arguments(this, result, _) }
+  string getLabel() { result = asDbInstance().(Db::Argument).getLabel() }

-  Expr getExpr() {
-    exists(Expr x |
-      arguments(this, _, x) and
-      result = x.resolve()
-    )
+  Expr getImmediateExpr() {
+    result = Cached::fromDbInstance(asDbInstance().(Db::Argument).getExpr())
  }
+
+  final Expr getExpr() { result = getImmediateExpr().resolve() }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/ArrayExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/ArrayExpr.qll
@@ -1,18 +1,21 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.CollectionExpr
 import codeql.swift.elements.expr.Expr

-class ArrayExprBase extends @array_expr, CollectionExpr {
+class ArrayExprBase extends Cached::TArrayExpr, CollectionExpr {
+  final override Db::ArrayExpr asDbInstance() { this = Cached::TArrayExpr(result) }
+
  override string getAPrimaryQlClass() { result = "ArrayExpr" }

-  Expr getElement(int index) {
-    exists(Expr x |
-      array_expr_elements(this, index, x) and
-      result = x.resolve()
-    )
+  Expr getImmediateElement(int index) {
+    result = Cached::fromDbInstance(asDbInstance().(Db::ArrayExpr).getElement(index))
  }

-  Expr getAnElement() { result = getElement(_) }
+  final Expr getElement(int index) { result = getImmediateElement(index).resolve() }

-  int getNumberOfElements() { result = count(getAnElement()) }
+  final Expr getAnElement() { result = getElement(_) }
+
+  final int getNumberOfElements() { result = count(getAnElement()) }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/ArrayToPointerExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/ArrayToPointerExpr.qll
@@ -1,6 +1,12 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.ImplicitConversionExpr

-class ArrayToPointerExprBase extends @array_to_pointer_expr, ImplicitConversionExpr {
+class ArrayToPointerExprBase extends Cached::TArrayToPointerExpr, ImplicitConversionExpr {
+  final override Db::ArrayToPointerExpr asDbInstance() {
+    this = Cached::TArrayToPointerExpr(result)
+  }
+
  override string getAPrimaryQlClass() { result = "ArrayToPointerExpr" }
 }
--- a/swift/ql/lib/codeql/swift/generated/expr/ArrowExpr.qll
+++ b/swift/ql/lib/codeql/swift/generated/expr/ArrowExpr.qll
@@ -1,6 +1,10 @@
 // generated by codegen/codegen.py
+private import codeql.swift.generated.IpaTypes
+private import codeql.swift.generated.Db
 import codeql.swift.elements.expr.Expr

-class ArrowExprBase extends @arrow_expr, Expr {
+class ArrowExprBase extends Cached::TArrowExpr, Expr {
+  final override Db::ArrowExpr asDbInstance() { this = Cached::TArrowExpr(result) }
+
  override string getAPrimaryQlClass() { result = "ArrowExpr" }
 }
--- a/Show More
+++ b/Show More