Merge pull request #17435 from github/rust-experiment

Rust: merge current status of experimental extractor into main
2026-04-25 00:35:20 +02:00 · 2024-09-11 17:31:24 +02:00
parent 07bd854868 fea6017688
commit f9e4c0af13
327 changed files with 18441 additions and 81 deletions
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -30,6 +30,10 @@ Ruby:
  - ruby/**/*
  - change-notes/**/*ruby*

+Rust:
+  - rust/**/*
+  - change-notes/**/*rust*
+
 Swift:
  - swift/**/*
  - change-notes/**/*swift*
--- a/.github/workflows/check-change-note.yml
+++ b/.github/workflows/check-change-note.yml
@@ -16,11 +16,12 @@ on:
      - "shared/**/*.qll"
      - "!**/experimental/**"
      - "!ql/**"
+      - "!rust/**"
      - ".github/workflows/check-change-note.yml"

 jobs:
  check-change-note:
-    env: 
+    env:
      REPO: ${{ github.repository }}
      PULL_REQUEST_NUMBER: ${{ github.event.number }}
      GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -33,7 +34,7 @@ jobs:
          !contains(github.event.pull_request.labels.*.name, 'no-change-note-required')
        run: |
          change_note_files=$(gh api "repos/$REPO/pulls/$PULL_REQUEST_NUMBER/files" --paginate --jq '.[].filename | select(test("/change-notes/.*[.]md$"))')
-          
+
          if [ -z "$change_note_files" ]; then
            echo "No change note found. Either add one, or add the 'no-change-note-required' label."
            exit 1
--- a/.github/workflows/ruby-build.yml
+++ b/.github/workflows/ruby-build.yml
@@ -65,8 +65,8 @@ jobs:
        id: cache-extractor
        with:
          path: |
-            ruby/extractor/target/release/codeql-extractor-ruby
-            ruby/extractor/target/release/codeql-extractor-ruby.exe
+            target/release/codeql-extractor-ruby
+            target/release/codeql-extractor-ruby.exe
            ruby/extractor/ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
          key: ${{ runner.os }}-${{ steps.os_version.outputs.version }}-ruby-extractor-${{ hashFiles('ruby/extractor/rust-toolchain.toml', 'ruby/extractor/Cargo.lock') }}-${{ hashFiles('shared/tree-sitter-extractor') }}-${{ hashFiles('ruby/extractor/**/*.rs') }}
      - uses: actions/cache@v3
@@ -75,7 +75,7 @@ jobs:
          path: |
            ~/.cargo/registry
            ~/.cargo/git
-            ruby/target
+            target
          key: ${{ runner.os }}-${{ steps.os_version.outputs.version }}-ruby-rust-cargo-${{ hashFiles('ruby/extractor/rust-toolchain.toml', 'ruby/extractor/**/Cargo.lock') }}
      - name: Check formatting
        if: steps.cache-extractor.outputs.cache-hit != 'true'
@@ -91,7 +91,7 @@ jobs:
        run: cd extractor && cargo build --release
      - name: Generate dbscheme
        if: ${{ matrix.os == 'ubuntu-latest' && steps.cache-extractor.outputs.cache-hit != 'true'}}
-        run: extractor/target/release/codeql-extractor-ruby generate --dbscheme ql/lib/ruby.dbscheme --library ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
+        run: ../target/release/codeql-extractor-ruby generate --dbscheme ql/lib/ruby.dbscheme --library ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
      - uses: actions/upload-artifact@v3
        if: ${{ matrix.os == 'ubuntu-latest' }}
        with:
@@ -106,8 +106,8 @@ jobs:
        with:
          name: extractor-${{ matrix.os }}
          path: |
-            ruby/extractor/target/release/codeql-extractor-ruby
-            ruby/extractor/target/release/codeql-extractor-ruby.exe
+            target/release/codeql-extractor-ruby
+            target/release/codeql-extractor-ruby.exe
          retention-days: 1
  compile-queries:
    if: github.repository_owner == 'github'
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -0,0 +1,51 @@
+name: "Rust"
+
+on:
+  pull_request:
+    paths:
+      - "rust/**"
+      - "misc/bazel/**"
+      - "misc/codegen/**"
+      - "shared/**"
+      - "MODULE.bazel"
+      - .github/workflows/rust.yml
+      - .github/actions/**
+      - codeql-workspace.yml
+      - "!**/*.md"
+      - "!**/*.qhelp"
+    branches:
+      - rust-experiment
+      - main
+      - rc/*
+      - codeql-cli-*
+
+permissions:
+  contents: read
+
+jobs:
+  rust-check:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Format
+        working-directory: rust/extractor
+        shell: bash
+        run: |
+          cargo fmt --check
+      - name: Compilation
+        working-directory: rust/extractor
+        shell: bash
+        run: cargo check
+      - name: Clippy
+        working-directory: rust/extractor
+        shell: bash
+        run: |
+          cargo clippy --fix
+          git diff --exit-code
+      - name: Code generation
+        shell: bash
+        run: |
+          bazel run //rust/codegen
+          git add .
+          git diff --exit-code HEAD
--- a/.gitignore
+++ b/.gitignore
@@ -65,3 +65,9 @@ node_modules/

 # bazel-built in-tree extractor packs
 /*/extractor-pack
+
+# Jetbrains IDE files
+.idea
+
+# cargo build directory
+/target
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -5,9 +5,9 @@ repos:
    rev: v3.2.0
    hooks:
      - id: trailing-whitespace
-        exclude: /test/.*$(?<!\.ql)(?<!\.qll)(?<!\.qlref)|.*\.patch
+        exclude: /test/.*$(?<!\.qlref)|.*\.patch$|.*\.qll?$
      - id: end-of-file-fixer
-        exclude: /test/.*$(?<!\.ql)(?<!\.qll)(?<!\.qlref)|.*\.patch
+        exclude: /test/.*$(?<!\.qlref)|.*\.patch$|.*\.qll?$

  - repo: https://github.com/pre-commit/mirrors-clang-format
    rev: v17.0.6
@@ -45,7 +45,7 @@ repos:

      - id: sync-files
        name: Fix files required to be identical
-        files: \.(qll?|qhelp|swift)$|^config/identical-files\.json$
+        files: \.(qll?|qhelp|swift|toml)$|^config/identical-files\.json$
        language: system
        entry: python3 config/sync-files.py --latest
        pass_filenames: false
@@ -58,7 +58,7 @@ repos:

      - id: swift-codegen
        name: Run Swift checked in code generation
-        files: ^swift/(schema.py$|codegen/|.*/generated/|ql/lib/(swift\.dbscheme$|codeql/swift/elements)|ql/\.generated.list)
+        files: ^misc/codegen/|^swift/(schema.py$|codegen/|.*/generated/|ql/lib/(swift\.dbscheme$|codeql/swift/elements)|ql/\.generated.list)
        language: system
        entry: bazel run //swift/codegen -- --quiet
        pass_filenames: false
@@ -69,3 +69,17 @@ repos:
        language: system
        entry: bazel test //misc/codegen/test
        pass_filenames: false
+
+      - id: rust-codegen
+        name: Run Rust checked in code generation
+        files: ^misc/codegen/|^rust/(schema.py$|codegen/|.*/generated/|ql/lib/(rust\.dbscheme$|codeql/rust/elements)|\.generated.list)
+        language: system
+        entry: bazel run //rust/codegen -- --quiet
+        pass_filenames: false
+
+      - id: rust-lint
+        name: Run fmt and clippy on Rust code
+        files: ^rust/extractor/(.*rs|Cargo.toml)$
+        language: system
+        entry: python3 rust/lint.py
+        pass_filenames: false
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -0,0 +1,14 @@
+# This is the shared workspace file for extractor using shared/tree-sitter/extractor
+[workspace]
+
+resolver = "2"
+members = [
+    "shared/tree-sitter-extractor",
+    "ruby/extractor",
+    "rust/extractor",
+]
+
+[patch.crates-io]
+# patch for build script bug preventing bazel build
+# see https://github.com/rust-lang/rustc_apfloat/pull/17
+rustc_apfloat = { git = "https://github.com/redsun82/rustc_apfloat.git", rev = "096d585100636bc2e9f09d7eefec38c5b334d47b" }
--- a/MODULE.bazel
+++ b/MODULE.bazel
@@ -27,7 +27,7 @@ bazel_dep(name = "rules_kotlin", version = "1.9.4-codeql.1")
 bazel_dep(name = "gazelle", version = "0.38.0")
 bazel_dep(name = "rules_dotnet", version = "0.15.1")
 bazel_dep(name = "googletest", version = "1.14.0.bcr.1")
-bazel_dep(name = "rules_rust", version = "0.49.3")
+bazel_dep(name = "rules_rust", version = "0.50.0")

 bazel_dep(name = "buildifier_prebuilt", version = "6.4.0", dev_dependency = True)

@@ -47,21 +47,23 @@ cp.from_cargo(
 )
 use_repo(cp, "py_deps")

-# crate_ruby, but shortened due to windows file paths
+# deps for ruby+rust, but shortened due to windows file paths
 r = use_extension(
    "@rules_rust//crate_universe:extension.bzl",
    "crate",
    isolate = True,
 )
 r.from_cargo(
-    name = "rd",
-    cargo_lockfile = "//ruby/extractor:Cargo.lock",
+    name = "r",
+    cargo_lockfile = "//:Cargo.lock",
    manifests = [
+        "//:Cargo.toml",
        "//ruby/extractor:Cargo.toml",
-        "//ruby/extractor/codeql-extractor-fake-crate:Cargo.toml",
+        "//rust/extractor:Cargo.toml",
+        "//shared/tree-sitter-extractor:Cargo.toml",
    ],
 )
-use_repo(r, ruby_deps = "rd")
+use_repo(r, tree_sitter_extractors_deps = "r")

 dotnet = use_extension("@rules_dotnet//dotnet:extensions.bzl", "dotnet")
 dotnet.toolchain(dotnet_version = "8.0.101")
--- a/config/identical-files.json
+++ b/config/identical-files.json
@@ -355,9 +355,5 @@
  "Python model summaries test extension": [
    "python/ql/test/library-tests/dataflow/model-summaries/InlineTaintTest.ext.yml",
    "python/ql/test/library-tests/dataflow/model-summaries/NormalDataflowTest.ext.yml"
-  ],
-  "shared tree-sitter extractor cargo.toml": [
-    "shared/tree-sitter-extractor/Cargo.toml",
-    "ruby/extractor/codeql-extractor-fake-crate/Cargo.toml"
  ]
 }
--- a/misc/codegen/codegen.py
+++ b/misc/codegen/codegen.py
@@ -30,8 +30,8 @@ def _parse_args() -> argparse.Namespace:

    p = argparse.ArgumentParser(description="Code generation suite")
    p.add_argument("--generate", type=lambda x: x.split(","),
-                   help="specify what targets to generate as a comma separated list, choosing among dbscheme, ql, trap "
-                        "and cpp")
+                   help="specify what targets to generate as a comma separated list, choosing among dbscheme, ql, "
+                        "trap, cpp and rust")
    p.add_argument("--verbose", "-v", action="store_true", help="print more information")
    p.add_argument("--quiet", "-q", action="store_true", help="only print errors")
    p.add_argument("--configuration-file", "-c", type=_abspath, default=conf,
@@ -57,6 +57,9 @@ def _parse_args() -> argparse.Namespace:
        p.add_argument("--cpp-output",
                       help="output directory for generated C++ files, required if trap or cpp is provided to "
                            "--generate"),
+        p.add_argument("--rust-output",
+                       help="output directory for generated Rust files, required if rust is provided to "
+                            "--generate"),
        p.add_argument("--generated-registry",
                       help="registry file containing information about checked-in generated code. A .gitattributes"
                            "file is generated besides it to mark those files with linguist-generated=true. Must"
--- a/misc/codegen/generators/init.py
+++ b/misc/codegen/generators/init.py
@@ -1,4 +1,4 @@
-from . import dbschemegen, qlgen, trapgen, cppgen
+from . import dbschemegen, trapgen, cppgen, rustgen, rusttestgen, qlgen


 def generate(target, opts, renderer):
--- a/misc/codegen/generators/qlgen.py
+++ b/misc/codegen/generators/qlgen.py
@@ -26,6 +26,7 @@ import re
 import subprocess
 import typing
 import itertools
+import os

 import inflection

@@ -287,7 +288,7 @@ def _is_under_qltest_collapsed_hierarchy(cls: schema.Class, lookup: typing.Dict[
        _is_in_qltest_collapsed_hierarchy(lookup[b], lookup) for b in cls.bases)


-def _should_skip_qltest(cls: schema.Class, lookup: typing.Dict[str, schema.Class]):
+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_hierarchy(
        cls, lookup)
@@ -370,8 +371,10 @@ def generate(opts, renderer):

    imports = {}
    generated_import_prefix = get_import(out, opts.root_dir)
+    registry = opts.generated_registry or pathlib.Path(
+        os.path.commonpath((out, stub_out, test_out)), ".generated.list")

-    with renderer.manage(generated=generated, stubs=stubs, registry=opts.generated_registry,
+    with renderer.manage(generated=generated, stubs=stubs, registry=registry,
                         force=opts.force) as renderer:

        db_classes = [cls for name, cls in classes.items() if not data.classes[name].synth]
@@ -413,7 +416,7 @@ def generate(opts, renderer):

        if test_out:
            for c in data.classes.values():
-                if _should_skip_qltest(c, data.classes):
+                if should_skip_qltest(c, data.classes):
                    continue
                test_with = data.classes[c.test_with] if c.test_with else c
                test_dir = test_out / test_with.group / test_with.name
--- a/misc/codegen/generators/rustgen.py
+++ b/misc/codegen/generators/rustgen.py
@@ -0,0 +1,109 @@
+"""
+Rust trap class generation
+"""
+
+import functools
+import typing
+
+import inflection
+
+from misc.codegen.lib import rust, schema
+from misc.codegen.loaders import schemaloader
+
+
+def _get_type(t: str) -> str:
+    match t:
+        case None:  # None means a predicate
+            return "bool"
+        case "string":
+            return "String"
+        case "int":
+            return "usize"
+        case _ if t[0].isupper():
+            return "trap::Label"
+        case "boolean":
+            assert False, "boolean unsupported"
+        case _:
+            return t
+
+
+def _get_field(cls: schema.Class, p: schema.Property) -> rust.Field:
+    table_name = inflection.tableize(cls.name)
+    if not p.is_single:
+        table_name = f"{cls.name}_{p.name}"
+        if p.is_predicate:
+            table_name = inflection.underscore(table_name)
+        else:
+            table_name = inflection.tableize(table_name)
+    args = dict(
+        field_name=rust.avoid_keywords(p.name),
+        base_type=_get_type(p.type),
+        is_optional=p.is_optional,
+        is_repeated=p.is_repeated,
+        is_predicate=p.is_predicate,
+        is_unordered=p.is_unordered,
+        table_name=table_name,
+    )
+    args.update(rust.get_field_override(p.name))
+    return rust.Field(**args)
+
+
+def _get_properties(
+    cls: schema.Class, lookup: dict[str, schema.Class],
+) -> typing.Iterable[tuple[schema.Class, schema.Property]]:
+    for b in cls.bases:
+        yield from _get_properties(lookup[b], lookup)
+    for p in cls.properties:
+        yield cls, p
+
+
+class Processor:
+    def __init__(self, data: schema.Schema):
+        self._classmap = data.classes
+
+    def _get_class(self, name: str) -> rust.Class:
+        cls = self._classmap[name]
+        return rust.Class(
+            name=name,
+            fields=[
+                _get_field(c, p)
+                for c, p in _get_properties(cls, self._classmap)
+                if "rust_skip" not in p.pragmas and not p.synth
+            ],
+            table_name=inflection.tableize(cls.name),
+        )
+
+    def get_classes(self):
+        ret = {"": []}
+        for k, cls in self._classmap.items():
+            if not cls.synth and not cls.derived:
+                ret.setdefault(cls.group, []).append(self._get_class(cls.name))
+        return ret
+
+
+def generate(opts, renderer):
+    assert opts.rust_output
+    processor = Processor(schemaloader.load_file(opts.schema))
+    out = opts.rust_output
+    groups = set()
+    with renderer.manage(generated=out.rglob("*.rs"),
+                         stubs=(),
+                         registry=out / ".generated.list",
+                         force=opts.force) as renderer:
+        for group, classes in processor.get_classes().items():
+            group = group or "top"
+            groups.add(group)
+            renderer.render(
+                rust.ClassList(
+                    classes,
+                    opts.schema,
+                ),
+                out / f"{group}.rs",
+            )
+        renderer.render(
+            rust.ModuleList(
+                groups,
+                opts.schema,
+            ),
+            out / f"mod.rs",
+        )
--- a/misc/codegen/generators/rusttestgen.py
+++ b/misc/codegen/generators/rusttestgen.py
@@ -0,0 +1,64 @@
+import dataclasses
+import typing
+import inflection
+
+from misc.codegen.loaders import schemaloader
+from . import qlgen
+
+
+@dataclasses.dataclass
+class Param:
+    name: str
+    type: str
+    first: bool = False
+
+
+@dataclasses.dataclass
+class Function:
+    name: str
+    signature: str
+
+
+@dataclasses.dataclass
+class TestCode:
+    template: typing.ClassVar[str] = "rust_test_code"
+
+    code: str
+    function: Function | None = None
+
+
+def generate(opts, renderer):
+    assert opts.ql_test_output
+    schema = schemaloader.load_file(opts.schema)
+    with renderer.manage(generated=opts.ql_test_output.rglob("gen_*.rs"),
+                         stubs=(),
+                         registry=opts.ql_test_output / ".generated_tests.list",
+                         force=opts.force) as renderer:
+        for cls in schema.classes.values():
+            if (qlgen.should_skip_qltest(cls, schema.classes) or
+                    "rust_skip_test_from_doc" in cls.pragmas or
+                    not cls.doc):
+                continue
+            code = []
+            adding_code = False
+            has_code = False
+            for line in cls.doc:
+                match line, adding_code:
+                    case "```", _:
+                        adding_code = not adding_code
+                        has_code = True
+                    case _, False:
+                        code.append(f"// {line}")
+                    case _, True:
+                        code.append(line)
+            if not has_code:
+                continue
+            test_name = inflection.underscore(cls.name)
+            signature = cls.rust_doc_test_function
+            fn = signature and Function(f"test_{test_name}", signature)
+            if fn:
+                indent = 4 * " "
+                code = [indent + l for l in code]
+            test_with = schema.classes[cls.test_with] if cls.test_with else cls
+            test = opts.ql_test_output / test_with.group / test_with.name / f"gen_{test_name}.rs"
+            renderer.render(TestCode(code="\n".join(code), function=fn), test)
--- a/misc/codegen/lib/rust.py
+++ b/misc/codegen/lib/rust.py
@@ -0,0 +1,138 @@
+import dataclasses
+import re
+import typing
+
+# taken from https://doc.rust-lang.org/reference/keywords.html
+keywords = {
+    "as",
+    "break",
+    "const",
+    "continue",
+    "crate",
+    "else",
+    "enum",
+    "extern",
+    "false",
+    "fn",
+    "for",
+    "if",
+    "impl",
+    "in",
+    "let",
+    "loop",
+    "match",
+    "mod",
+    "move",
+    "mut",
+    "pub",
+    "ref",
+    "return",
+    "self",
+    "Self",
+    "static",
+    "struct",
+    "super",
+    "trait",
+    "true",
+    "type",
+    "unsafe",
+    "use",
+    "where",
+    "while",
+    "async",
+    "await",
+    "dyn",
+    "abstract",
+    "become",
+    "box",
+    "do",
+    "final",
+    "macro",
+    "override",
+    "priv",
+    "typeof",
+    "unsized",
+    "virtual",
+    "yield",
+    "try",
+}
+
+
+def avoid_keywords(s: str) -> str:
+    return s + "_" if s in keywords else s
+
+
+_field_overrides = [
+    (re.compile(r"(.*)_"), lambda m: {"field_name": m[1]}),
+]
+
+
+def get_field_override(field: str):
+    for r, o in _field_overrides:
+        m = r.fullmatch(field)
+        if m:
+            return o(m) if callable(o) else o
+    return {}
+
+
+@dataclasses.dataclass
+class Field:
+    field_name: str
+    base_type: str
+    table_name: str
+    is_optional: bool = False
+    is_repeated: bool = False
+    is_unordered: bool = False
+    is_predicate: bool = False
+    first: bool = False
+
+    def __post_init__(self):
+        self.field_name = avoid_keywords(self.field_name)
+
+    @property
+    def type(self) -> str:
+        type = self.base_type
+        if self.is_optional:
+            type = f"Option<{type}>"
+        if self.is_repeated:
+            type = f"Vec<{type}>"
+        return type
+
+    @property
+    def is_single(self):
+        return not (self.is_optional or self.is_repeated or self.is_predicate)
+
+    @property
+    def is_label(self):
+        return self.base_type == "trap::Label"
+
+
+@dataclasses.dataclass
+class Class:
+    name: str
+    table_name: str
+    fields: list[Field] = dataclasses.field(default_factory=list)
+
+    @property
+    def single_field_entries(self):
+        ret = {self.table_name: []}
+        for f in self.fields:
+            if f.is_single:
+                ret.setdefault(f.table_name, []).append(f)
+        return [{"table_name": k, "fields": v} for k, v in ret.items()]
+
+
+@dataclasses.dataclass
+class ClassList:
+    template: typing.ClassVar[str] = "rust_classes"
+
+    classes: list[Class]
+    source: str
+
+
+@dataclasses.dataclass
+class ModuleList:
+    template: typing.ClassVar[str] = "rust_module"
+
+    modules: list[str]
+    source: str
--- a/misc/codegen/lib/schema.py
+++ b/misc/codegen/lib/schema.py
@@ -94,6 +94,7 @@ class Class:
    default_doc_name: Optional[str] = None
    hideable: bool = False
    test_with: Optional[str] = None
+    rust_doc_test_function: Optional["FunctionInfo"] = None  # TODO: parametrized pragmas

    @property
    def final(self):
--- a/misc/codegen/lib/schemadefs.py
+++ b/misc/codegen/lib/schemadefs.py
@@ -52,6 +52,7 @@ class _SynthModifier(_schema.PropertyModifier, _Namespace):
 qltest = _Namespace()
 ql = _Namespace()
 cpp = _Namespace()
+rust = _Namespace()
 synth = _SynthModifier()


@@ -156,6 +157,10 @@ _Pragma("ql_internal")

 _Pragma("cpp_skip")

+_Pragma("rust_skip_doc_test")
+
+rust.doc_test_signature = lambda signature: _annotate(rust_doc_test_function=signature)
+

 def group(name: str = "") -> _ClassDecorator:
    return _annotate(group=name)
--- a/misc/codegen/loaders/schemaloader.py
+++ b/misc/codegen/loaders/schemaloader.py
@@ -56,6 +56,7 @@ def _get_class(cls: type) -> schema.Class:
                        ],
                        doc=schema.split_doc(cls.__doc__),
                        default_doc_name=cls.__dict__.get("_doc_name"),
+                        rust_doc_test_function=cls.__dict__.get("_rust_doc_test_function")
                        )


--- a/misc/codegen/schema_documentation.md
+++ b/misc/codegen/schema_documentation.md
--- a/misc/codegen/templates/rust_classes.mustache
+++ b/misc/codegen/templates/rust_classes.mustache
@@ -0,0 +1,54 @@
+// generated by {{generator}}
+
+#![cfg_attr(any(), rustfmt::skip)]
+
+use crate::trap::{TrapId, TrapEntry};
+use codeql_extractor::trap;
+{{#classes}}
+
+#[derive(Debug)]
+pub struct {{name}} {
+    pub id: TrapId,
+    {{#fields}}
+    pub {{field_name}}: {{type}},
+    {{/fields}}
+}
+
+impl TrapEntry for {{name}} {
+    fn extract_id(&mut self) -> TrapId {
+        std::mem::replace(&mut self.id, TrapId::Star)
+    }
+
+    fn emit(self, id: trap::Label, out: &mut trap::Writer) {
+        {{#single_field_entries}}
+        out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{#fields}}, self.{{field_name}}.into(){{/fields}}]);
+        {{/single_field_entries}}
+        {{#fields}}
+        {{#is_predicate}}
+        if self.{{field_name}} {
+            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id)]);
+        }
+        {{/is_predicate}}
+        {{#is_optional}}
+        {{^is_repeated}}
+        if let Some(v) = self.{{field_name}} {
+            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id), v.into()]);
+        }
+        {{/is_repeated}}
+        {{/is_optional}}
+        {{#is_repeated}}
+        for (i, v) in self.{{field_name}}.into_iter().enumerate() {
+            {{^is_optional}}
+            out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
+            {{/is_optional}}
+            {{#is_optional}}
+            if let Some(v) = v {
+                out.add_tuple("{{table_name}}", vec![trap::Arg::Label(id){{^is_unordered}}, i.into(){{/is_unordered}}, v.into()]);
+            }
+            {{/is_optional}}
+        }
+        {{/is_repeated}}
+        {{/fields}}
+    }
+}
+{{/classes}}
--- a/misc/codegen/templates/rust_module.mustache
+++ b/misc/codegen/templates/rust_module.mustache
@@ -0,0 +1,6 @@
+// generated by {{generator}}
+{{#modules}}
+
+mod {{.}};
+pub use {{.}}::*;
+{{/modules}}
--- a/misc/codegen/templates/rust_test_code.mustache
+++ b/misc/codegen/templates/rust_test_code.mustache
@@ -0,0 +1,9 @@
+// generated by {{generator}}
+
+{{#function}}
+fn {{name}}{{signature}} {
+{{/function}}
+{{code}}
+{{#function}}
+}
+{{/function}}
--- a/ruby/Makefile
+++ b/ruby/Makefile
@@ -24,7 +24,7 @@ FILES=codeql-extractor.yml\
      ql/lib/ruby.dbscheme.stats\
      ql/lib/ruby.dbscheme

-BIN_FILES=target/release/codeql-extractor-ruby$(EXE)
+BIN_FILES=../target/release/codeql-extractor-ruby$(EXE)

 extractor-common:
 	rm -rf build
@@ -37,14 +37,14 @@ extractor-common:
 tools: $(BIN_FILES)
 	rm -rf tools/bin
 	mkdir tools/bin
-	cp -r target/release/codeql-extractor-ruby$(EXE) tools/bin/extractor$(EXE)
+	cp -r ../target/release/codeql-extractor-ruby$(EXE) tools/bin/extractor$(EXE)

-target/release/%$(EXE):
+../target/release/%$(EXE):
 	cd extractor && cargo build --release

 dbscheme:
 	cd extractor && cargo build --release
-	extractor/target/release/codeql-extractor-ruby generate --dbscheme ql/lib/ruby.dbscheme --library ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
+	../target/release/codeql-extractor-ruby generate --dbscheme ql/lib/ruby.dbscheme --library ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
 	codeql query format -i ql/lib/codeql/ruby/ast/internal/TreeSitter.qll

 .PHONY:	extractor
@@ -62,7 +62,7 @@ extractor:	$(FILES) $(BIN_FILES)
 	cp tools/autobuild.cmd extractor-pack/tools/autobuild.cmd
 	cp ql/lib/ruby.dbscheme.stats extractor-pack/ruby.dbscheme.stats
 	cp ql/lib/ruby.dbscheme extractor-pack/ruby.dbscheme
-	cp extractor/target/release/codeql-extractor-ruby$(EXE) extractor-pack/tools/$(CODEQL_PLATFORM)/extractor$(EXE)
+	cp ../target/release/codeql-extractor-ruby$(EXE) extractor-pack/tools/$(CODEQL_PLATFORM)/extractor$(EXE)

 test: extractor dbscheme
 	codeql test run --check-databases --check-unused-labels --check-repeated-labels --check-redefined-labels --check-use-before-definition --search-path .. --consistency-queries ql/consistency-queries ql/test
--- a/ruby/actions/create-extractor-pack/action.yml
+++ b/ruby/actions/create-extractor-pack/action.yml
@@ -18,7 +18,7 @@ runs:
        path: |
          ~/.cargo/registry
          ~/.cargo/git
-          ruby/target
+          target
        key: ${{ runner.os }}-${{ steps.os_version.outputs.version }}-ruby-qltest-cargo-${{ hashFiles('ruby/extractor/rust-toolchain.toml', 'ruby/scripts/create-extractor-pack.sh', 'ruby/extractor/**/Cargo.lock') }}
    - name: Build Extractor
      if: steps.cache-extractor.outputs.cache-hit != 'true'
--- a/ruby/extractor/.cargo/config.toml
+++ b/ruby/extractor/.cargo/config.toml
@@ -1 +0,0 @@
-paths = ["../../shared/tree-sitter-extractor"]
--- a/ruby/extractor/BUILD.bazel
+++ b/ruby/extractor/BUILD.bazel
@@ -1,4 +1,4 @@
-load("@ruby_deps//:defs.bzl", "aliases", "all_crate_deps")
+load("@tree_sitter_extractors_deps//:defs.bzl", "aliases", "all_crate_deps")
 load("//misc/bazel:rust.bzl", "codeql_rust_binary")

 codeql_rust_binary(
--- a/ruby/extractor/Cargo.lock
+++ b/ruby/extractor/Cargo.lock
--- a/ruby/extractor/Cargo.toml
+++ b/ruby/extractor/Cargo.toml
@@ -1,4 +1,3 @@
-[workspace]
 [package]
 name = "codeql-extractor-ruby"
 description = "CodeQL Ruby extractor"
@@ -16,8 +15,6 @@ tracing-subscriber = { version = "0.3.3", features = ["env-filter"] }
 rayon = "1.5.0"
 regex = "1.7.1"
 encoding = "0.2"
-lazy_static = "1.4.0" 
-# Ideally, we'd like to pull this in via a relative path.
-# However, our bazel/rust tooling chokes on this, c.f. https://github.com/bazelbuild/rules_rust/issues/1525
-# Therefore, we have a pretty bad hack in place instead, see README.md in the codeql-extractor-fake-crate directory.
-codeql-extractor = { path = "codeql-extractor-fake-crate" }
+lazy_static = "1.4.0"
+
+codeql-extractor = { path = "../../shared/tree-sitter-extractor" }
--- a/ruby/extractor/codeql-extractor-fake-crate/BUILD.bazel
+++ b/ruby/extractor/codeql-extractor-fake-crate/BUILD.bazel
--- a/ruby/extractor/codeql-extractor-fake-crate/Cargo.toml
+++ b/ruby/extractor/codeql-extractor-fake-crate/Cargo.toml
@@ -1,26 +0,0 @@
-[package]
-name = "codeql-extractor"
-version = "0.2.0"
-edition = "2021"
-authors = ["GitHub"]
-
-[dependencies]
-flate2 = "1.0"
-globset = "0.4"
-tree-sitter = ">= 0.23.0"
-tracing = "0.1"
-tracing-subscriber = { version = "0.3.3", features = ["env-filter"] }
-rayon = "1.5.0"
-regex = "1.7.1"
-encoding = "0.2"
-lazy_static = "1.4.0"
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-chrono = { version = "0.4.19", features = ["serde"] }
-num_cpus = "1.14.0"
-
-[dev-dependencies]
-tree-sitter-ql = { git = "https://github.com/tree-sitter/tree-sitter-ql" }
-tree-sitter-json = {git = "https://github.com/tree-sitter/tree-sitter-json" }
-rand = "0.8.5"
-
--- a/ruby/extractor/codeql-extractor-fake-crate/README.md
+++ b/ruby/extractor/codeql-extractor-fake-crate/README.md
@@ -1,7 +0,0 @@
-We're presenting a fake crate in this workspace that ensures that the correct crate dependencies from the shared tree sitter
-extractor can be parsed by Bazel (which doesn't resolve path dependencies outside of the cargo workspace unfortunately).
-
-The sync-identical-files script keeps this up-to-date.
-For local development and IDEs, we override the path to `codeql-extractor` using the `.cargo/config.toml` mechanism.
-Bazel doesn't actually do anything with path dependencies except to pull in their dependency tree, so we manually
-specify the dependency from the ruby extractor to the shared extractor in `BUILD.bazel`.
--- a/ruby/extractor/codeql-extractor-fake-crate/src/lib.rs
+++ b/ruby/extractor/codeql-extractor-fake-crate/src/lib.rs
@@ -1 +0,0 @@
-
--- a/ruby/scripts/create-extractor-pack.sh
+++ b/ruby/scripts/create-extractor-pack.sh
@@ -8,10 +8,12 @@ else
  echo "Unknown OS"
  exit 1
 fi
+cd "$(dirname "$0")/.."

 (cd extractor && cargo build --release)

-BIN_DIR=extractor/target/release
+# we are in a cargo workspace rooted at the git checkout
+BIN_DIR=../target/release
 "$BIN_DIR/codeql-extractor-ruby" generate --dbscheme ql/lib/ruby.dbscheme --library ql/lib/codeql/ruby/ast/internal/TreeSitter.qll

 codeql query format -i ql/lib/codeql/ruby/ast/internal/TreeSitter.qll
--- a/rust/BUILD.bazel
+++ b/rust/BUILD.bazel
@@ -0,0 +1,65 @@
+load("@rules_pkg//pkg:mappings.bzl", "pkg_filegroup")
+load(
+    "//misc/bazel:pkg.bzl",
+    "codeql_pack",
+    "codeql_pkg_files",
+)
+
+package(default_visibility = ["//rust:__subpackages__"])
+
+filegroup(
+    name = "schema",
+    srcs = ["schema.py"],
+)
+
+filegroup(
+    name = "schema-includes",
+    srcs = glob(["*.dbscheme"]),
+)
+
+filegroup(
+    name = "codegen-conf",
+    srcs = ["codegen.conf"],
+)
+
+codeql_pkg_files(
+    name = "tools-arch",
+    exes = ["//rust/extractor"],
+    prefix = "{CODEQL_PLATFORM}",
+)
+
+pkg_filegroup(
+    name = "tools",
+    srcs = [
+        ":tools-arch",
+        "//rust/tools",
+    ],
+    prefix = "tools",
+)
+
+codeql_pkg_files(
+    name = "root-files",
+    srcs = [
+        "codeql-extractor.yml",
+        "ql/lib/rust.dbscheme",
+        "ql/lib/rust.dbscheme.stats",
+    ],
+)
+
+[
+    codeql_pack(
+        name = "-".join(parts),
+        srcs = [
+            ":root-files",
+            ":tools",
+        ],
+        pack_prefix = "/".join(parts),
+    )
+    for parts in (
+        [
+            "experimental",
+            "rust",
+        ],
+        ["rust"],
+    )
+]
--- a/rust/README.md
+++ b/rust/README.md
@@ -0,0 +1,43 @@
+# Rust on CodeQL
+
+> [!WARNING]
+> Rust support for CodeQL is experimental. No support is offered. QL and database interfaces will change and break without notice or deprecation periods.
+
+## Development
+
+### Dependencies
+
+If you don't have the `semmle-code` repo you may need to install Bazel manually, e.g. from https://github.com/bazelbuild/bazelisk.
+
+### Building the Rust Extractor
+
+This approach uses a released `codeql` version and is simpler to use for QL development. From your `semmle-code` directory run:
+```bash
+bazel run @codeql//rust:rust-installer
+```
+You now need to create a [per-user CodeQL configuration file](https://docs.github.com/en/code-security/codeql-cli/using-the-advanced-functionality-of-the-codeql-cli/specifying-command-options-in-a-codeql-configuration-file#using-a-codeql-configuration-file) and specify the option:
+```
+--search-path PATH/TO/semmle-code/ql
+```
+(wherever the `codeql` checkout is on your system)
+
+You can now use the Rust extractor e.g. to run Rust tests from the command line or in VSCode.
+
+### Building the Rust Extractor (as a sembuild target)
+
+This approach allows you to build a Rust extractor with a CLI built from source. From your `semmle-code` directory run:
+```bash
+./build target/intree/codeql-rust
+```
+You can now invoke it directly, for example to run some tests:
+```bash
+./target/intree/codeql-rust/codeql test run ql/rust/ql/test/PATH/TO/TEST/
+```
+
+### Building a Database
+
+TODO
+
+### Code Generation
+
+TODO
--- a/rust/codegen.conf
+++ b/rust/codegen.conf
@@ -0,0 +1,8 @@
+# configuration file for Swift code generation default options
+--generate=dbscheme,rusttest,ql,rust
+--dbscheme=ql/lib/rust.dbscheme
+--ql-output=ql/lib/codeql/rust/generated
+--ql-stub-output=ql/lib/codeql/rust/elements
+--ql-test-output=ql/test/extractor-tests/generated
+--rust-output=extractor/src/generated
+--script-name=codegen
--- a/rust/codegen/BUILD.bazel
+++ b/rust/codegen/BUILD.bazel
@@ -0,0 +1,15 @@
+load("@bazel_skylib//rules:native_binary.bzl", "native_binary")
+
+native_binary(
+    name = "codegen",
+    src = "//misc/codegen",
+    out = "codegen",
+    args = [
+        "--configuration-file=$(location //rust:codegen-conf)",
+    ],
+    data = [
+        "//rust:codegen-conf",
+        "//rust:schema",
+    ],
+    visibility = ["//rust:__subpackages__"],
+)
--- a/rust/codeql-extractor.yml
+++ b/rust/codeql-extractor.yml
@@ -0,0 +1,36 @@
+name: "rust"
+display_name: "Rust"
+version: 0.1.0
+column_kind: "utf8"
+legacy_qltest_extraction: true
+build_modes:
+  - none
+github_api_languages:
+  - Rust
+scc_languages:
+  - Rust
+file_types:
+  - name: rust
+    display_name: Rust files
+    extensions:
+      - .rs
+options:
+  trap:
+    title: Options pertaining to TRAP.
+    type: object
+    properties:
+      compression:
+        title: Controls compression for the TRAP files written by the extractor.
+        description: >
+          This option is only intended for use in debugging the extractor. Accepted
+          values are 'gzip' (the default, to write gzip-compressed TRAP) and 'none'
+          (to write uncompressed TRAP).
+        type: string
+        pattern: "^(none|gzip)$"
+  extract_dependencies:
+    title: Whether to extract dependencies.
+    description: >
+      Extract the source code of dependencies and the standard libraries in addition to 
+      normal source code.
+    type: string
+    pattern: "^(false|true)$"
--- a/rust/extractor/.gitignore
+++ b/rust/extractor/.gitignore
@@ -0,0 +1,2 @@
+/target
+/.idea
--- a/rust/extractor/BUILD.bazel
+++ b/rust/extractor/BUILD.bazel
@@ -0,0 +1,17 @@
+load("@tree_sitter_extractors_deps//:defs.bzl", "aliases", "all_crate_deps")
+load("//misc/bazel:rust.bzl", "codeql_rust_binary")
+
+codeql_rust_binary(
+    name = "extractor",
+    srcs = glob(["src/**/*.rs"]),
+    aliases = aliases(),
+    proc_macro_deps = all_crate_deps(
+        proc_macro = True,
+    ),
+    visibility = ["//rust:__subpackages__"],
+    deps = all_crate_deps(
+        normal = True,
+    ) + [
+        "//shared/tree-sitter-extractor:codeql-extractor",
+    ],
+)
--- a/rust/extractor/Cargo.toml
+++ b/rust/extractor/Cargo.toml
@@ -0,0 +1,28 @@
+[package]
+name = "codeql-rust"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1.0.86"
+clap = { version = "4.5.16", features = ["derive"] }
+figment = { version = "0.10.19", features = ["env"]}
+log = "0.4.22"
+num-traits = "0.2.19"
+ra_ap_base_db = "0.0.232"
+ra_ap_hir = "0.0.232"
+ra_ap_hir_def = "0.0.232"
+ra_ap_ide_db = "0.0.232"
+ra_ap_load-cargo = "0.0.232"
+ra_ap_paths = "0.0.232"
+ra_ap_project_model = "0.0.232"
+ra_ap_syntax = "0.0.232"
+ra_ap_vfs = "0.0.232"
+serde = "1.0.209"
+serde_with = "3.9.0"
+stderrlog = "0.6.0"
+triomphe = "0.1.13"
+# Ideally, we'd like to pull this in via a relative path.
+# However, our bazel/rust tooling chokes on this, c.f. https://github.com/bazelbuild/rules_rust/issues/1525
+# Therefore, we have a pretty bad hack in place instead, see README.md in the codeql-extractor-fake-crate directory.
+codeql-extractor = { path = "../../shared/tree-sitter-extractor" }
--- a/rust/extractor/src/archive.rs
+++ b/rust/extractor/src/archive.rs
@@ -0,0 +1,29 @@
+use crate::path;
+use log::{debug, warn};
+use std::fs;
+use std::path::{Path, PathBuf};
+
+pub struct Archiver {
+    pub root: PathBuf,
+}
+
+impl Archiver {
+    pub fn archive(&self, source: &Path) {
+        if let Err(e) = self.try_archive(source) {
+            warn!("unable to archive {}: {e}", source.display());
+        }
+    }
+
+    fn try_archive(&self, source: &Path) -> std::io::Result<()> {
+        let mut dest = self.root.clone();
+        dest.push(path::key(source));
+        let parent = dest.parent().unwrap();
+        if fs::metadata(&dest).is_ok() {
+            return Ok(());
+        }
+        fs::create_dir_all(parent)?;
+        fs::copy(source, dest)?;
+        debug!("archived {}", source.display());
+        Ok(())
+    }
+}
--- a/rust/extractor/src/config.rs
+++ b/rust/extractor/src/config.rs
@@ -0,0 +1,81 @@
+use anyhow::Context;
+use clap::{ArgAction, Parser, ValueEnum};
+use codeql_extractor::trap;
+use figment::{
+    providers::{Env, Serialized},
+    Figment,
+};
+use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
+
+#[derive(Debug, PartialEq, Eq, Default, Serialize, Deserialize, Clone, Copy, ValueEnum)]
+#[serde(rename_all = "lowercase")]
+#[clap(rename_all = "lowercase")]
+pub enum Compression {
+    #[default] // TODO make gzip default
+    None,
+    Gzip,
+}
+
+impl From<Compression> for trap::Compression {
+    fn from(val: Compression) -> Self {
+        match val {
+            Compression::None => Self::None,
+            Compression::Gzip => Self::Gzip,
+        }
+    }
+}
+
+#[serde_with::apply(_ => #[serde(default)])]
+#[derive(Debug, Deserialize, Default)]
+pub struct Config {
+    pub scratch_dir: PathBuf,
+    pub trap_dir: PathBuf,
+    pub source_archive_dir: PathBuf,
+    pub extract_dependencies: bool,
+    pub verbose: u8,
+    pub compression: Compression,
+    pub inputs: Vec<PathBuf>,
+}
+
+#[serde_with::apply(_ => #[serde(skip_serializing_if = "is_default")])]
+#[derive(clap::Parser, Serialize)]
+#[command(about, long_about = None)]
+struct CliArgs {
+    #[arg(long)]
+    scratch_dir: Option<PathBuf>,
+    #[arg(long)]
+    trap_dir: Option<PathBuf>,
+    #[arg(long)]
+    source_archive_dir: Option<PathBuf>,
+    #[arg(long)]
+    compression: Option<Compression>,
+    #[arg(short, long, action = ArgAction::Count)]
+    verbose: u8,
+    #[arg(long)]
+    inputs_file: Option<PathBuf>,
+
+    inputs: Vec<PathBuf>,
+}
+
+fn is_default<T: Default + PartialEq>(t: &T) -> bool {
+    *t == Default::default()
+}
+
+impl Config {
+    pub fn extract() -> anyhow::Result<Config> {
+        let mut cli_args = CliArgs::parse();
+        if let Some(inputs_file) = cli_args.inputs_file.take() {
+            let inputs_list = std::fs::read_to_string(inputs_file).context("reading file list")?;
+            cli_args
+                .inputs
+                .extend(inputs_list.split_terminator("\n").map(PathBuf::from));
+        }
+        Figment::new()
+            .merge(Env::prefixed("CODEQL_EXTRACTOR_RUST_"))
+            .merge(Env::prefixed("CODEQL_EXTRACTOR_RUST_OPTION_"))
+            .merge(Serialized::defaults(cli_args))
+            .extract()
+            .context("loading configuration")
+    }
+}
--- a/rust/extractor/src/generated/.generated.list
+++ b/rust/extractor/src/generated/.generated.list
@@ -0,0 +1,2 @@
+mod.rs 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e
+top.rs 569909061b9a993481764765a014327d143939778f2dbc79836e7496cdb83e1f 569909061b9a993481764765a014327d143939778f2dbc79836e7496cdb83e1f
--- a/rust/extractor/src/generated/.gitattributes
+++ b/rust/extractor/src/generated/.gitattributes
@@ -0,0 +1,4 @@
+/.generated.list linguist-generated
+/.gitattributes linguist-generated
+/mod.rs linguist-generated
+/top.rs linguist-generated
--- a/rust/extractor/src/generated/mod.rs
+++ b/rust/extractor/src/generated/mod.rs
@@ -0,0 +1,4 @@
+// generated by codegen
+
+mod top;
+pub use top::*;
--- a/rust/extractor/src/generated/top.rs
+++ b/rust/extractor/src/generated/top.rs
--- a/rust/extractor/src/main.rs
+++ b/rust/extractor/src/main.rs
@@ -0,0 +1,94 @@
+use crate::trap::TrapId;
+use anyhow::Context;
+use ra_ap_hir::db::DefDatabase;
+use ra_ap_hir::Crate;
+use ra_ap_load_cargo::{load_workspace_at, LoadCargoConfig, ProcMacroServerChoice};
+use ra_ap_project_model::CargoConfig;
+use ra_ap_project_model::RustLibSource;
+use ra_ap_vfs::AbsPathBuf;
+use std::path::PathBuf;
+
+mod archive;
+mod config;
+pub mod generated;
+pub mod path;
+mod translate;
+pub mod trap;
+
+fn find_project_manifests(
+    files: &[PathBuf],
+) -> anyhow::Result<Vec<ra_ap_project_model::ProjectManifest>> {
+    let current = std::env::current_dir()?;
+    let abs_files: Vec<_> = files
+        .iter()
+        .map(|path| AbsPathBuf::assert_utf8(current.join(path)))
+        .collect();
+    Ok(ra_ap_project_model::ProjectManifest::discover_all(
+        &abs_files,
+    ))
+}
+
+fn main() -> anyhow::Result<()> {
+    let cfg = config::Config::extract().context("failed to load configuration")?;
+    stderrlog::new()
+        .module(module_path!())
+        .verbosity(2 + cfg.verbose as usize)
+        .init()?;
+    log::info!("{cfg:?}");
+    let traps = trap::TrapFileProvider::new(&cfg).context("failed to set up trap files")?;
+    let archiver = archive::Archiver {
+        root: cfg.source_archive_dir,
+    };
+
+    let config = CargoConfig {
+        sysroot: Some(RustLibSource::Discover),
+        target_dir: ra_ap_paths::Utf8PathBuf::from_path_buf(cfg.scratch_dir)
+            .map(|x| x.join("target"))
+            .ok(),
+        ..Default::default()
+    };
+    let progress = |t| (log::info!("progress: {}", t));
+    let load_config = LoadCargoConfig {
+        load_out_dirs_from_check: true,
+        with_proc_macro_server: ProcMacroServerChoice::Sysroot,
+        prefill_caches: false,
+    };
+    let projects = find_project_manifests(&cfg.inputs).context("loading inputs")?;
+    for project in projects {
+        let (db, vfs, _macro_server) = load_workspace_at(
+            project.manifest_path().as_ref(),
+            &config,
+            &load_config,
+            &progress,
+        )?;
+
+        let crates = <dyn DefDatabase>::crate_graph(&db);
+        for crate_id in crates.iter() {
+            let krate = Crate::from(crate_id);
+            let name = krate.display_name(&db);
+            let crate_name = name
+                .as_ref()
+                .map(|n| n.canonical_name().as_str())
+                .unwrap_or("");
+            let trap = traps.create(
+                "crates",
+                &PathBuf::from(format!(
+                    "/{}_{}",
+                    crate_name,
+                    crate_id.into_raw().into_u32()
+                )),
+            );
+            translate::CrateTranslator::new(
+                &db,
+                trap,
+                &krate,
+                &vfs,
+                &archiver,
+                cfg.extract_dependencies,
+            )
+            .emit_crate()
+            .context("writing trap file")?;
+        }
+    }
+    Ok(())
+}
--- a/rust/extractor/src/path.rs
+++ b/rust/extractor/src/path.rs
@@ -0,0 +1,10 @@
+use std::fs::canonicalize;
+use std::path::{absolute, Path, PathBuf};
+
+pub fn key(p: &Path) -> PathBuf {
+    let normalized = canonicalize(p)
+        .or_else(|_| absolute(p))
+        .unwrap_or_else(|_| p.into());
+    let root = normalized.ancestors().last().unwrap(); // ancestors always yields at least one
+    normalized.strip_prefix(root).unwrap().into() // stripping an ancestor always works
+}
--- a/rust/extractor/src/translate.rs
+++ b/rust/extractor/src/translate.rs
--- a/rust/extractor/src/trap.rs
+++ b/rust/extractor/src/trap.rs
@@ -0,0 +1,166 @@
+use crate::config::Compression;
+use crate::generated;
+use crate::{config, path};
+use codeql_extractor::trap;
+use log::debug;
+use ra_ap_ide_db::line_index::LineCol;
+use std::ffi::OsString;
+use std::fmt::Debug;
+use std::path::{Path, PathBuf};
+
+//TODO: typed labels
+pub trait AsTrapKeyPart {
+    fn as_key_part(&self) -> String;
+}
+
+impl AsTrapKeyPart for trap::Label {
+    fn as_key_part(&self) -> String {
+        format!("{{{}}}", self)
+    }
+}
+
+impl AsTrapKeyPart for String {
+    fn as_key_part(&self) -> String {
+        self.clone()
+    }
+}
+
+impl AsTrapKeyPart for &str {
+    fn as_key_part(&self) -> String {
+        String::from(*self)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub enum TrapId {
+    Star,
+    Key(String),
+    Label(trap::Label),
+}
+
+impl From<String> for TrapId {
+    fn from(value: String) -> Self {
+        TrapId::Key(value)
+    }
+}
+
+impl From<&str> for TrapId {
+    fn from(value: &str) -> Self {
+        TrapId::Key(value.into())
+    }
+}
+
+impl From<trap::Label> for TrapId {
+    fn from(value: trap::Label) -> Self {
+        TrapId::Label(value)
+    }
+}
+
+#[macro_export]
+macro_rules! trap_key {
+    ($($x:expr),+ $(,)?) => {{
+        let mut key = String::new();
+        $(
+            key.push_str(&$x.as_key_part());
+        )*
+        $crate::TrapId::Key(key)
+    }};
+}
+
+pub trait TrapEntry: std::fmt::Debug {
+    fn extract_id(&mut self) -> TrapId;
+    fn emit(self, id: trap::Label, out: &mut trap::Writer);
+}
+
+pub struct TrapFile {
+    path: PathBuf,
+    writer: trap::Writer,
+    compression: Compression,
+}
+
+impl TrapFile {
+    pub fn emit_location(
+        &mut self,
+        file_label: trap::Label,
+        start: LineCol,
+        end: LineCol,
+    ) -> trap::Label {
+        let start_line = 1 + start.line as usize;
+        let start_column = 1 + start.col as usize;
+        let end_line = 1 + end.line as usize;
+        let end_column = 1 + end.col as usize;
+        let (ret, _) = self.writer.location_label(trap::Location {
+            file_label,
+            start_line,
+            start_column,
+            end_line,
+            end_column,
+        });
+        self.emit(generated::DbLocation {
+            id: ret.into(),
+            file: file_label,
+            start_line,
+            start_column,
+            end_line,
+            end_column,
+        });
+        ret
+    }
+
+    pub fn label(&mut self, id: TrapId) -> trap::Label {
+        match id {
+            TrapId::Star => self.writer.fresh_id(),
+            TrapId::Key(s) => self.writer.global_id(&s).0,
+            TrapId::Label(l) => l,
+        }
+    }
+
+    pub fn emit<T: TrapEntry>(&mut self, mut e: T) -> trap::Label {
+        let label = self.label(e.extract_id());
+        e.emit(label, &mut self.writer);
+        label
+    }
+
+    pub fn commit(&self) -> std::io::Result<()> {
+        std::fs::create_dir_all(self.path.parent().unwrap())?;
+        self.writer
+            .write_to_file(&self.path, self.compression.into())
+    }
+}
+
+pub struct TrapFileProvider {
+    trap_dir: PathBuf,
+    compression: Compression,
+}
+
+impl TrapFileProvider {
+    pub fn new(cfg: &config::Config) -> std::io::Result<TrapFileProvider> {
+        let trap_dir = cfg.trap_dir.clone();
+        std::fs::create_dir_all(&trap_dir)?;
+        Ok(TrapFileProvider {
+            trap_dir,
+            compression: cfg.compression,
+        })
+    }
+
+    pub fn create(&self, category: &str, key: &Path) -> TrapFile {
+        let mut path = PathBuf::from(category);
+        path.push(path::key(key));
+        path.set_extension(
+            path.extension()
+                .map(|e| {
+                    let mut o: OsString = e.to_owned();
+                    o.push(".trap");
+                    o
+                })
+                .unwrap_or("trap".into()),
+        );
+        debug!("creating trap file {}", path.display());
+        path = self.trap_dir.join(path);
+        TrapFile {
+            path,
+            writer: trap::Writer::new(),
+            compression: self.compression,
+        }
+    }
+}
--- a/rust/integration-tests/test.py
+++ b/rust/integration-tests/test.py
@@ -0,0 +1,4 @@
+# dummy test to get CI going
+
+def test(codeql, rust):
+    pass
--- a/rust/lint.py
+++ b/rust/lint.py
@@ -0,0 +1,16 @@
+#!/bin/env python3
+
+import subprocess
+import pathlib
+import shutil
+import sys
+
+extractor_dir = pathlib.Path(__file__).resolve().parent / "extractor"
+
+cargo = shutil.which("cargo")
+assert cargo, "no cargo binary found on `PATH`"
+
+fmt = subprocess.run([cargo, "fmt", "--quiet"], cwd=extractor_dir)
+clippy = subprocess.run([cargo, "clippy", "--fix", "--allow-dirty", "--allow-staged", "--quiet"],
+                        cwd=extractor_dir)
+sys.exit(fmt.returncode or clippy.returncode)
--- a/rust/prefix.dbscheme
+++ b/rust/prefix.dbscheme
@@ -0,0 +1,6 @@
+/**
+ * The source location of the snapshot.
+ */
+sourceLocationPrefix(
+  string prefix: string ref
+);
--- a/rust/ql/.generated.list
+++ b/rust/ql/.generated.list
@@ -0,0 +1,223 @@
+lib/codeql/rust/elements/ArrayExpr.qll aa558ac94bb7c45145e4788ed1a92e2873c5f57f1a0c7b7faf341f40027cf455 874da62a3d6467af7ae11045229135f8f5229cff33f3edae5b01a5b9afe86dd7
+lib/codeql/rust/elements/AstNode.qll 2069047c779514867c12d845dcdf889db6f27fa6a9e484966a3c28a77973b7d4 e214616c81418b0018c0d36896ac2ec7273634e3213bc8257d8b172f396c00ee
+lib/codeql/rust/elements/AsyncBlockExpr.qll ce6484a28403bc36e261ae6931b02a15db6fc54cc0c1bfc441e33d7284f6c74a e5b3c00f74543a6ceeaef053aaa1f00006026b8242efbeb7e1e9633e68cc4844
+lib/codeql/rust/elements/AsyncBlockExprConstructor.qll 2d7d22caca1984e850d723f9ddd581530734bf4c31c545ea598bc27144a32f1b bf2ff9edff95db8400017b7583d6881581c431755c70e0068a495787993010f9
+lib/codeql/rust/elements/AwaitExpr.qll 310cf2cf155bc472caed76f596d7f789e9fa19c24d73dc0235d601ff9f32de40 d4b53d79a12d4378eebe2211b37b0f819177620b86a3eabfbec4096adfd200c4
+lib/codeql/rust/elements/AwaitExprConstructor.qll af0dfdf36b300d412a7b8668f68e6594fe3338216cdf1aa420c9a58608aa86f5 cfa115902ccf070e34ee451bc2f89295c97e8418501359a8cdc646d16c4cc7cd
+lib/codeql/rust/elements/BecomeExpr.qll 91e08545258ff3bed8b63cb0e719f71f04cf21af758688cdb39d4be56d104db7 ba381c94e998c2fa275ab84f1e785cfb6af5ab40ad690e6b429eb72897837ac4
+lib/codeql/rust/elements/BecomeExprConstructor.qll 0c206e657417066415850672a804a69e5fccc605c309bb8755737ae01e332f18 e70bd0c411ffc23c37b22a459455c95ff75a72fa2d179f751bff99866eeef2bc
+lib/codeql/rust/elements/BinaryOpExpr.qll d85404c249175283d7ac7daada3951f47b19ef56b08749906c8bd3895959db9f 9e1d35061bab3517c716e3d0fe42654568e16b6577d6d26861b87576839a33be
+lib/codeql/rust/elements/BinaryOpExprConstructor.qll efa89c084def020961641772f4829fc54bf718817831d4752b9bf403ce0e61dd d7937326ba08410fc3ba37e44b76530804f492177ef5e62dd416094e1e2f9bd6
+lib/codeql/rust/elements/BindPat.qll f0209f781d8a14ab7fbb4b4d6a654469aecb0ff1a8ff4810f18a90f3b171e1c3 9734b7907855e46eeded6c3f59912a16212f7e8639fba35c740bb04462240287
+lib/codeql/rust/elements/BindPatConstructor.qll 2bbcc296bcdcd945313d83294b90d327c51c9f1e96f92d37dd10bf0c32dfaf6a 612b4fc651f32129155727e866796edee8fff939614c6fd0b7baa1392930a38c
+lib/codeql/rust/elements/BlockExpr.qll cd7a978d3ad15156467ee213d65ef0dcc806af43888d1de4635e875b2d76f5fb b0286039d03f2f554ab5c31b902386357e19127d35f70211b1373d591053ed8f
+lib/codeql/rust/elements/BlockExprBase.qll 1b24ea5fd43dce0e240e1d7740a062228c19e8c704f6ce26503ddbd65c6f5282 d2e05a51d3840caf4de4cca6cdab9551f396df317c8ad1da661205aa822646cc
+lib/codeql/rust/elements/BlockExprConstructor.qll 7fc9214582f0e6e8b4db06f7c6ac3712dc260abc12ff65f3e93bec5f210b0098 13bc676b67ed14b326e4bdaaa43b497ce486dc2c3145a76a25fe960c82a6ba54
+lib/codeql/rust/elements/BoxExpr.qll 02e6f063c8e2aa01b12eb3223783e8d88330f4faadd71fef253b5dd39af8b556 bda6357d99430b524de82be0da444cc180dde9ba1f3e08c1bd4c53143789fcf0
+lib/codeql/rust/elements/BoxExprConstructor.qll e30e71b88978b5d0f156152acaf7eaebe26232b7a5a562cf22f1bb9659ae5deb 3ca41494c5101ef73877737420fbc468483ac7ef215d11b431dac2dd6a08ecc5
+lib/codeql/rust/elements/BoxPat.qll 1df08d5443c63e21d40d25023da58da50bd6cf6e156b9f5dbd6d41a3193faee9 9837752be4d4a1c3f16d6438bd361c596b6b983d9ae4e486083651e8f4e090ff
+lib/codeql/rust/elements/BoxPatConstructor.qll 20f79f18beb8b7eeec63b1e30302d9f2e514354a7b1ae077f240db3cda4ecc4c f41ca3fdafc70c6b972598a3af3434bf60687bc2f0252dd11ddd09ec874fe63c
+lib/codeql/rust/elements/BreakExpr.qll b760b1f9ba612aa29c917a25d75143e90bbdb607d12ea4a49067ab44595292c1 ee0bf075f2b237c1513cdd03dd35666d4c9158dbf1216a30c5aec05db9e6d317
+lib/codeql/rust/elements/BreakExprConstructor.qll 48b71a034b7b6b0ecda47c72379696c6d4ebb9eadcd6403f9c001945855c5365 fbbccb6d1718393ad6ff3a2bd473dd51691c871db9181cb1e041b318f91d27a7
+lib/codeql/rust/elements/CallExpr.qll 7b76acfa945d7cc04bab4012fc8476f8e4f9970b7051ea02fe5b12ec57927897 57ebf163cd6db203f5dd05d629f68bc4e39666ebc4d1252ba1e09b88ffbe60ef
+lib/codeql/rust/elements/CallExprConstructor.qll 9a7e9e780ff6604ddf0b9e5f27bfa43b720bb341673c7740148561c666ccd066 945804ba7c1dbfb9f221810be9d2fc3dbee3ce89dd9d08b3f3e719d31701ed98
+lib/codeql/rust/elements/CastExpr.qll cdd74a040d6b1aa44f6e2bdb2991e642f013848f32a17588291317a7abf38961 06f3228ac826fc452d75505345707b912426f05db78380a72f0ba586fa00c282
+lib/codeql/rust/elements/CastExprConstructor.qll cab6e9a9872006cc811620bda522fafde23fc4edb5151af06a5a0938747dbdfb 6d972faff70166c4b07392a0bc90c6d72c9466b58b55e7651ef6c3d06cf72873
+lib/codeql/rust/elements/ClosureExpr.qll 2a8b0a94e37b8406acee038ae0737604174b3062f3c12ecea27a3104ded3b2bb 904eed60004ad20c0d03965f91e1d2227cccf3b13ce29341c79d545aabe492f0
+lib/codeql/rust/elements/ClosureExprConstructor.qll 238dceb78082a5566276640d4aa31484041700852c0751130d139a69ac8bde46 7aae22930def4d438d742255731cc59b78a95b73a0b1d6334ae9965e083e03bc
+lib/codeql/rust/elements/ConstBlockPat.qll af7f5f1a8de38266a12e92dee4a5ef5279baccf542cf2c52d982ed075d3bec27 1208223d97230a90d9377164b61454dcc6ca0f46a408e4a5ab2a82340bc92eb3
+lib/codeql/rust/elements/ConstBlockPatConstructor.qll 04aa8b4f218ce87157f0d6b10c9c04660c34c90af1f121b1432402de2e5114cd 34e2fecbe91ea9ac1626bc27121a7d5abe99855e3f49bdca12a1969b42ac0ba5
+lib/codeql/rust/elements/ConstExpr.qll df129a4a1f65c07076e15097571ffd12b91a63d3ded97bb3173b50a7f1279bb4 dd3b7a5230baf5d1a062d49324eeb6ee5a76f156944ec149da8bf46c982107b8
+lib/codeql/rust/elements/ConstExprConstructor.qll b4c96adc2878047c36d7ceaba2346ef66a2269b5260a56c3d7ff6e3a332bad75 ce15bbfd1448e47d3039e912363efa607cc2c29d44b8248ac91c307af7b57016
+lib/codeql/rust/elements/ContinueExpr.qll 46635ab257d8cc8ab3ba4b6786df7a2ff4d2e6360578bebde8bec1d6ae90b8c7 a0c60fb018ced67e1d6eed1c493b2c6d729636f1325b556ed5bcbcff072cd8d7
+lib/codeql/rust/elements/ContinueExprConstructor.qll adc5c5b4fda5dc5102cdace41c32a6c94fe07a2e2555ced6ee62a2d2551b90a2 9dc5045b0d91a3a28cc1c0d59c6fd40620257a6c18ea8480792183c4d802fd8a
+lib/codeql/rust/elements/DbFile.qll 056d363e1ba5ec08cacb2e90b8a7a3b47f52ded5dc2289edd4e85921fc50f37e 18e6926f77265a3a6319ca2f3bf3d529d17d46cebdd2ef6753357fdc53c22c70
+lib/codeql/rust/elements/DbFileConstructor.qll ea93dc49b23b1c6d800ab9d0b9cacfa9dc661bfdb04b9e6efcad2bdb050fb0ab f7a891b1786604eee57a784733555b677e2580770d51d18073b59e7ca65df1d4
+lib/codeql/rust/elements/DbLocation.qll 1f694594e8e4ab65a8781cd443ad4f864447ca88e2cb65504aee5a779393c84d 003ec72275406eb8f5ddd6ccc2b258fb7c906d4bb2c0ef1ba235f291624321ca
+lib/codeql/rust/elements/DbLocationConstructor.qll 8848abace985818a5d3a6eddfc4cb200795970146d282b037b4f22ae6230b894 44dba880e17bb1072fa12451ccaae4830fd04dcc61f7403d35510309fde6906e
+lib/codeql/rust/elements/Declaration.qll d4ec5c83728f1837243caf2f27d06fd05ecdd2ca440112accff99bfd37b45e5f c1cd9b297be8b69207e75d24b29949b9f71c78406ee0ffd38d0b0810288d6140
+lib/codeql/rust/elements/ElementListExpr.qll ec535846c4f449a3e58bb3b8dc583960ef3b42a10836ad13a6c3091f625ab463 3797f92086ecab90406b7493953d78af27b0b5c68199e2f37abc15f3d1cf88ed
+lib/codeql/rust/elements/ElementListExprConstructor.qll 12b06597e0700cd0eac70e42cbdc1a2d410e0ffcd05c21a213812a488b5b236b 7adb2e442f1bc362c44824aaba0ab4a7fb4a4bc550a3c96f963dc03bed582d39
+lib/codeql/rust/elements/Expr.qll a0c2cb3ff9628e5dd1a7900d2413390faa433dcef114bdc85279a3a2bf2fc4d8 a0e8e5693ead91b62da5531e070e11a2105ee49046cb69e63b8747eeafc27651
+lib/codeql/rust/elements/ExprStmt.qll afe41d6d05ed9d94b3c8529dad743bdf3e2a0e68bed84a80da4dd6df0257451d c1f0c7c1a3c62baffb7d3bb69cc4bc828e6fbbbabe8f87342ec67d8744fcbe7e
+lib/codeql/rust/elements/ExprStmtConstructor.qll 28e37020abdfce5a8666b0c9a3147c339c7a90d9de527f97fc7d36df2bb921ba 5333db932a2edb791ec3c8f2c215f4c74e825a362f45ee901949d81e328bc7fd
+lib/codeql/rust/elements/FieldExpr.qll 1e3d84c3eeeeefa1837b5359f7289c0f03122848b6f95fdb362cfd947304e107 28a6f8201b435b87705afcb8088d017fa699f60be3aefe03dd56f978ac7954d7
+lib/codeql/rust/elements/FieldExprConstructor.qll 75bd0526fae157460750f3ea1e087c857cc703fca03d34f1f478b57ee8051590 1e5555910c643235e34b73f9844e894e51f357c3f7aba8165c47caa147336c53
+lib/codeql/rust/elements/FunctionConstructor.qll a9269b37182c0bf432f9b2b015691da5dbd64819b9bd25445af229d873014a91 69107a7503af14a51e091e6918094a4e9fc316a72de2e1514f001872ce0f2c0c
+lib/codeql/rust/elements/IfExpr.qll d5461ea0370765b9dd0c5aae298e53c9b3d84bacc783991fb9dceee44c87e8fb 90c5f959144c767bc8f10b322489264b076c33f19af0d19e97a08d083f76913b
+lib/codeql/rust/elements/IfExprConstructor.qll 961ac42fe811db7c56c9d85e98724a87571e8543265c0424a7b61f26ef41b369 43d9412a22908a7e5c38f1f5e8f88162367407b71037f469dfb7d8dfdc3a063f
+lib/codeql/rust/elements/IndexExpr.qll 0729277577ffe82d6dbc8fd275a70de59a3926aafea730e622ecbbca7b84e313 c9bc5616664e072fbaef2b89d4047f5f7e28d002cca2fa17333f29db80adb284
+lib/codeql/rust/elements/IndexExprConstructor.qll 37e70c773123d775b6281514a2727e133e02fa87e774076f857a676697a1f2ba da2ed2819a13ab7c526b74c1c375ab2fce63ed17f61d5b29e4212343d6b77d06
+lib/codeql/rust/elements/InlineAsmExpr.qll 5883542b068a11c22917bd46e44eda2f5e4a9de67f5346acfaa2334f73ee63ad 9a8823c91daff1337aa60cbd6bf3b6e96ad1e8603dfe79dcf404636de2693a5f
+lib/codeql/rust/elements/InlineAsmExprConstructor.qll 5a3eb5162805366dcc2aea00714c1a0880c31b614b73b69f1638ff4f088cdb11 89c54b68b0246fe5d86f119c1892149746d7fe22d6ef8b625c9ab64398d19d26
+lib/codeql/rust/elements/ItemStmt.qll 70fc3f9df9794dc78199dfd81b8136701d4ca0c9b3c6e88ecec42f75fbc41f32 df122241e3868b1c376e2d2501328ad47020a0837826f165c7e54640bc018156
+lib/codeql/rust/elements/ItemStmtConstructor.qll cd27051f73ab2897b1f7a725313f97d36507fc9f5e0dd7b2ad8bd1caaf8c42ad 67596c97386fbe6cb9e5e6abc45b674158f411d927297345cb25359587380bcd
+lib/codeql/rust/elements/Label.qll f48209b24876d581e95120bc548c44033b6552a7875eea73ce44aa57b675eeb3 d17163f3adc9f94a462269f565153aa2822533d03487e521d9c5d5e72afaa1ac
+lib/codeql/rust/elements/LabelConstructor.qll 0625a149cb34b9f603b76efd76e679bb63808d47f9fa529959784347d8e7d447 2115bc7de878af444777f96247bc0a775161f3766e38c3c4d363c2f59b2144da
+lib/codeql/rust/elements/LetExpr.qll 986598132db0cbc861adc641e633a54b7651ff5f3bc52b5e2f4e84733b774fb5 e61ed80a6732fb344498c8eedf3b787546eaa38f203265e9a3195e93d3534a19
+lib/codeql/rust/elements/LetExprConstructor.qll 8904b25d70fd0e6f3db74d2e09bb3e3fee407282ee45030fdaeac31b6111db70 36dcc877f6c1810228d593d914cffa7b04ecf0afe13c4c122aca72f33d03f566
+lib/codeql/rust/elements/LetStmt.qll f9e28ca0123e2a6e1f6115821282440397cf2647577b4bfc4d00cbb4312d8eea c65442707090461035160ce830c4c0a85d1fe626f03026c13ebc4be06ec96905
+lib/codeql/rust/elements/LetStmtConstructor.qll 5882f0e4379d07e8281a955c9eed7dd907b610750887de3dd6451cd1c8d104d4 68b0890d8a493dcca74190904b00f05b0e58aacfe5a2aa63e5ead1ba366d3c38
+lib/codeql/rust/elements/LitPat.qll 539b414883b0b86ff446fa81254f2c71f467e5ea0bda21dc3bd66cf3abf95b13 d54eeb618cfb8f0c4a48ce5ab1922fca2622f4a0c703760aa344028172f37642
+lib/codeql/rust/elements/LitPatConstructor.qll 1a1c5f711b04bfc9b8b9a197564cc8acfeeaff1a9c8b30d57657747d84138fce 19cfa7386fd1f4ad8ba1ffe8b14bc547b9884dc98e731b6935afd11ceac6b5fe
+lib/codeql/rust/elements/LiteralExpr.qll c5abad970feff4cb2719cc4774aedcfbc494a68fe15e13c36eeb2516d26a88cb fdb399d9a6162be54c3cbdd83654b9736faee9b15aa111f1bbd6f333d332c87a
+lib/codeql/rust/elements/LiteralExprConstructor.qll 1a6aa25d6700ab9c85bd7b721e4818064a3a092386589ecdc2018b8b8c2464dc 6d6b50e2dabfa671110454d64f0903336563ee4be1dc6751071a801ac2fcb8e8
+lib/codeql/rust/elements/LoopExpr.qll 6596e1d8ef1e9479785871321021930244dfb7736111801aeacd08446f4d2238 5895e4a5d4187fcd852528f0cea99fa378d60d279c7896b221eca8e65109fb96
+lib/codeql/rust/elements/LoopExprConstructor.qll 635348fe22fb47c7e59bed02a8ed6420be5a9ce92a7d9bf4475465ee170c917b 2bcfe70247c55659b3a3e09562da52fc645cc3166748f268c5a38b35fca24233
+lib/codeql/rust/elements/MatchArm.qll f91def96700dd8521c11aef100f494d2d44777186e771b306ec9579b01c882af 021b298096cd88d3de81c2c012102e5b5ce5159d6dbca2bbd32b266593df335d
+lib/codeql/rust/elements/MatchArmConstructor.qll 49d134823a445a1ee995ebf5637fd0d736b9ab7f2b141026712f231ec4ed3389 f16e8adc8375e6a7334589d5732dcbe10f5ada9de7a12c549c55be3f028ec628
+lib/codeql/rust/elements/MatchExpr.qll 87eea89af08e7b9e4dc958aae0d35035fa8cee5fa7108f59cd0d3050dc70eb29 ceb061ce32c20c9aa12e6376474ea1ce1b8bb9c9b0e58b67abeb4bb666a18676
+lib/codeql/rust/elements/MatchExprConstructor.qll 74df937d7d8bfbfb02bdbf095595eb3f2129ed4c0854bae6d73b5b38d4fc902d 5c388c02f02462d843945111b72de12bce33c7c332d55993d903aeb250213407
+lib/codeql/rust/elements/MethodCallExpr.qll 2dd115a2e5ac298d9a81cab2718b7abdbe52825938ea88115913c82a0f2f7751 9733c353b9e6703ef812eb8b6395db49d6d656460c575dbd75d67fa96784a33c
+lib/codeql/rust/elements/MethodCallExprConstructor.qll c9e1137ba6b76eabd941ecaa27a5b43b6fc3ff445ad46d3f625ad086de0e0af6 47bc4c30182b891c7009ba536edad7393dc068b72d9dfc16b26174b15d49748e
+lib/codeql/rust/elements/MissingExpr.qll 2158f064d027975e3faba6a858b8e469c324544ae0923319b149fd5ec6548448 500ef109ceb36f5da72040fc733c7e98f94920f51d53d90fff3d86f85da0aad3
+lib/codeql/rust/elements/MissingExprConstructor.qll c51f4f6e897ef2107a27bd91ecf31ce875611b29a5a12238d5312b9489a35b8d b9ea3fdae459aba6c7ed9eb48edbc5bdbdb4cb41220fff81ed4cd256648612e0
+lib/codeql/rust/elements/MissingPat.qll eacee2eaede4adb8452a41c14c95c310d0731c2c60fdb818b3e94e34f418aed4 9f81567e8e9c02be0994764a082a2135a6bec952456c2413295f2b0a16e5eb5d
+lib/codeql/rust/elements/MissingPatConstructor.qll 7bff2fb7fe96388dd703cca5f0bb1d04cea5d1f0729bb54c6604b58e338c7d6b eec9fea46593b3850da111658848cb54cfa9992286eeee313a55def184cf7ec5
+lib/codeql/rust/elements/Module.qll d8995b361cc672f86a314bd53bd3e4d1ddb26b6afde62eb7c380923810785af0 3c10180c812d89a8116ac6e32cbd4d7ac2f549c8a76d327ed75c764b09251d52
+lib/codeql/rust/elements/ModuleConstructor.qll 109ed8c1b5c61cc1d3e8613aa8bb8c168dc1943c93b5b622fa79665751b78318 601526c7f56578883d261d14653fdad08329f80fea71de14a5ac5ce671a8d436
+lib/codeql/rust/elements/OffsetOfExpr.qll 1076421d48a639191b52ca36701e760ea20a6ed1c8ff8f0cf1607f557b9f9a58 9cadc919b51ef5b223ce2c827005acf879309c9cdb971e8479477f0646e7c70b
+lib/codeql/rust/elements/OffsetOfExprConstructor.qll 8034eb1d3510dffe9e38cdfcb57a0235ee01bb50e1fbaa6e5601e0e232c1977d 6e3b7c20a17fe4c45d503ba32264aea8f6dfdc69ccd95905a5bfb1e8b0cc91d0
+lib/codeql/rust/elements/OrPat.qll 9b5cf68d55c57c262a5d630852ff2e842f0caa3aca2a0b4491d601340917db63 c965eb43675b135f3ce11c1e8762af0b764c6d4c262f002f8b9a512ae59e8a03
+lib/codeql/rust/elements/OrPatConstructor.qll 9a24cc095adc55ae8ea66f68c695f42de0181a43e23d70e210c63351b47e2586 1f773ae88276289672d93708f4ae9f8c95199e7370a0c610a52c92b5e018e632
+lib/codeql/rust/elements/Pat.qll 197aa86d5f317669e38230a20460b271c1d82e830b84150dac65afb67059fa2a ed3e8c74e42ffd5df14dd88711d79660982170a42f9a605704a274298dbbfc41
+lib/codeql/rust/elements/PathExpr.qll 15d12b039c117e78fde972b098e22ce247e5a6df4f52685173241d76f6c18368 8e8222767d49c022b6a69ae8902e86a5be9ac3803301c6c9b409f265546da520
+lib/codeql/rust/elements/PathExprConstructor.qll 9db3d3ad160d897b65b8b8a62f3243f7ff80d8e2d27875b3cd2c2b046fb0f9b6 26c2ba19a04fba61af8aa0cd72602f7b02bf0e1b693ac9cd14c7ff6066412f75
+lib/codeql/rust/elements/PathPat.qll a49036bca0f3f023917fec3547876759987a34747e16b9a15ebb99c82ca9234c b4f77e6e29300f02cb845ab79d4a64edb654a398fe3d6c1a2306423e1c0a237b
+lib/codeql/rust/elements/PathPatConstructor.qll 476a38723c63bbfa2565946725c90f1224ac2c5283fde79bf14dcefce6f500ca e9e9b000cac44851772bd9ca519edc89e8518e89a0930df21af14a69f5b0e864
+lib/codeql/rust/elements/RangeExpr.qll 05a56b149adf83006243335be90c23eca71e981aea33c2d81dc8ad5cdef757bd 602bc5ec0ab5e7eaf9f1debbb80d2861d53b6de5d10011b50fa71208a6491cd2
+lib/codeql/rust/elements/RangeExprConstructor.qll a04153bf88dd71c3f516418bdb7377ded9db21c07f7ee6dd245ed8b44719d8f3 2d578f8dbc49da98694676d6a59bb9d58c6d2a200ffc893ffa90dca77878e38a
+lib/codeql/rust/elements/RangePat.qll 02f3e4647932553481c4d8b1e2d2da3551662a17d75f26f2fb7e9d77ef1d579d e2546bc74035d03c92aa7beab2abca73a587049c95710eb9b59f916363df1552
+lib/codeql/rust/elements/RangePatConstructor.qll c391431118ed6ce16f7b7126c5d43e61f07b98fab7b8bc48e9dfe22f7e21ed19 bbafe1c9595b0b004f7b27999a14df27d0710d5b058e7ab14dddd2fae058fc31
+lib/codeql/rust/elements/RecordFieldPat.qll e3f69b2c59d50807393928ef9be0b51af016f209cbae68cfde0fdf02b287f353 b24e256f850d1f0bbacea74c4879fee8bcedf47f65db091d7858302355751fa3
+lib/codeql/rust/elements/RecordFieldPatConstructor.qll 36859753aa70086c540a1700495fe6c414521553877bfdd56800f586eb577743 1b31233a5e6da0bf88aaf40c52fa08cfbca5b44088cd3f91957ce8c96f4aeaea
+lib/codeql/rust/elements/RecordLitExpr.qll f5c0377f0a1805d824052acbcaad393ba10b0f994a5ea6b6f60b5eec2c417c21 e61bb3750d19dad5c4e59dd0bb3a65430879f58909b735f7c28f378cd2217221
+lib/codeql/rust/elements/RecordLitExprConstructor.qll 7b676a8e0fd9ba5a932988e613fe3dda8b6b0430feed8791ef5585fd9cd81767 f7811928dd8269138d75f0a6dd1c60f70d18806227bd2caaa5cd4cc1341e9286
+lib/codeql/rust/elements/RecordLitField.qll 27bbc256f61f4428578155da47b1a1b3eef43fb5d4d98f168c66fa85337bde24 880aa885f2ba3d1866c6023360a206dc5095385adb908e953ce792beae90b2ca
+lib/codeql/rust/elements/RecordLitFieldConstructor.qll 0f83c9dc00937d90ee0d64d157458145078f5f3c87c9c0484600fdcc830ab207 e2852d5bc4f0174d94b90a2ee34fae1e6c4b24d5d8ccb58a51c520b12adf8512
+lib/codeql/rust/elements/RecordPat.qll 50f4a2401dc579f3900188043d412ccdd6c57c1da6636c105221cfe243307d32 7812f0e10ce1a8e70c8c45d0c87e52539f6b29469157463456d06c566e86c2dd
+lib/codeql/rust/elements/RecordPatConstructor.qll 93c794efa5050b86c458470224de7f3206c1a004b46ef374780f080a8e9a4ce0 157800f342de96095e118dbcfa20f8e65cc79ccae712e8e37bff1ba92a227fda
+lib/codeql/rust/elements/RefExpr.qll ed47e1a834f2af93197ceda685a368465f7eea59704c2b7df3ef59326e53c0e1 5676825b036eb4cb560238d86c8d1fac48a4e59d91110da0dc75eacd542bcc8e
+lib/codeql/rust/elements/RefExprConstructor.qll 4a2b9dd4ec2638a5ccfca268ba377980aab3179b27177e34e44e0e9dc6653b36 752f6f298369b8c0f59d49ca9e729c20aceb3559df68be416c7bbf65f578489d
+lib/codeql/rust/elements/RefPat.qll 00b2c32e09a02b336d516b7812aa7ffe6202bd1dcdf4ec2060a74ee7a4b1c5c3 90a4b3da60aec10b5d56f6364d0a022c1d7db5fe8cbb65a78f55651d23f9abe7
+lib/codeql/rust/elements/RefPatConstructor.qll 98497e0ef76bec0390a23aede2fc6f80050ad2d00bb60f1d473362111a53d4dd e4fde4e3e88c33daee90ab6d90ef2e38b36faedcfe1b6d6304f4eed92980b5b1
+lib/codeql/rust/elements/RepeatExpr.qll 24ae3d83a83fc40bcdc6ba5c397a31da388c9137308cecce7da6fc8ac622031a c8114ad0ca7197aa791ae76d1d42b53ebd6f6b98378a779c59727d4e4ec5dbf6
+lib/codeql/rust/elements/RepeatExprConstructor.qll 7e141ed538f1dd5debd83de045eadc74ef032acc8a64ee2e8ac760da60ede525 d20206b72b14d03f8a41571948210619ad7d7dc438ba04ae45d929776a11915d
+lib/codeql/rust/elements/ReturnExpr.qll b36dc07c367af16c5df6276b10e36d85dbaa500092c555679463f8db817bf6a4 4f95cc9d88bbb8403e35b270897a1ee9ddb4c8bef393b06d7a014d914ca5fdec
+lib/codeql/rust/elements/ReturnExprConstructor.qll 825501a55f7b5556ded49fc3c43d45b7d8325e3a1790a2af738a46df33b569a7 ef06e95f1919952e537027861660a4d7c79b832fdbe802bfa5bdc29ba0192f31
+lib/codeql/rust/elements/SlicePat.qll 3e88657bd488dcb1ce2fa6f4bf72a9f76c7bfbf64b695070efa0ad89a6af407b ad60e3d0eee368c21c46acb439b599d8867c82193c7279777fea10f3205bd272
+lib/codeql/rust/elements/SlicePatConstructor.qll b2885e663932f68ffecf87b4532f533e9177beddd715765474f454a9804afc8b ade153522a4773eb769f4f4d96fa07add34089f131b41a74534b28fbfd2bbb60
+lib/codeql/rust/elements/Stmt.qll bbe8414d75bdcfda90f47b853a04fc618f4d0b6d6cd3b662bb15d3a9e5cc7bda 714c6f8eba9882363bf1594f48c75d1a885f6e93adadbdecbbd8169ce08f7b98
+lib/codeql/rust/elements/TupleExpr.qll efcdda11afbbeeb237a9b7f84a5a59ca3a98b541bc660b58a41f1b1cdea56efb f416c57e7190e91bb36d4235ae017cdfa8e68f69b38c55c6e7a71eaff35e5bd3
+lib/codeql/rust/elements/TupleExprConstructor.qll e7cfe2da7457339e99263030e74715e5ca44828d74ea3f462b90a7e72c1e9302 b45006d9cc7664a5a659e7c74f415142e2397dc33fb1875ac3a6cf5ca39e709e
+lib/codeql/rust/elements/TuplePat.qll 17bad5b6a0be8e9b61addbd9a17bb387709147e8d2fb8a93ca9255a8a11bb822 7e84df64d0baf1b5329d47f4977fa5e8471fc323b2eeca8e942df93a48e04cbf
+lib/codeql/rust/elements/TuplePatConstructor.qll 505c4f440b47da576acd7e3fc69d6b49e8287f981a21e79919ded374200f2578 b295526303bcae982ddd8c6b544288c0b8b8d62984d6986319e7f17baeb7a19b
+lib/codeql/rust/elements/TupleStructPat.qll 50b7d89498dbe6737d97325037156c7689fd8d7e776d66fef9551f173fa3f2d6 f42edcf42be877424ecf2f11c90166a90f485249b24d73ed302294299d6a9bcd
+lib/codeql/rust/elements/TupleStructPatConstructor.qll 15a15362572ac2dc98ed3257f195f20bb8dfe34a1fe203cf2a1a193ce16c406f 9e590b50cf865f6bc573b6fc17acea073f0d9389be241b01e820d9f3f8f14acb
+lib/codeql/rust/elements/TypeRef.qll 223844544eab3e07b6edda805c6344fa8b486aeea7bbe62e4b98e235ce2008d8 7517748b0e7a57c925168f5ce7a31ecc1b59f7521a2095578f599b8d9045a4e5
+lib/codeql/rust/elements/TypeRefConstructor.qll f8b2e5ef15517890a8b2d56643f471ae64cc74c420187049e33b182417e72e4f 683611e732b842756e301a77625b385bca0c4969971020c9e11220a1aa665a29
+lib/codeql/rust/elements/UnaryOpExpr.qll 32e637510c03653cc28cb9a25a2873e9bf346aeb63ad2d7a571bfcbda45c59ce 044b22dd35491f9eafc6488fff5bc929aed12e2f36ac55883925c876978bf7cf
+lib/codeql/rust/elements/UnaryOpExprConstructor.qll 43db7afbd3535b7edc801d99d772233a734f4ed31eeee2ca74e7ab26cae33e87 7345f8d4cb958ee2fa83d3634285f12829bdd1cbac2697236d6fae062313ab6d
+lib/codeql/rust/elements/UnderscoreExpr.qll cd49049149e268524412a17394daaef696ddca63f1f452b369172b9643e94d82 228568c12efc7c055f2ff7cc08c2d0ae150f6356f77ccea98b7f8be3d6bb4806
+lib/codeql/rust/elements/UnderscoreExprConstructor.qll ea9f93fa6529ec4e5bf5c4a98959b2e013e83fce4a74ebfc476b10bce2b331b2 bc36b62fd4fec6fb388d82e2af2aafe0099138d54b7672be81e84fc511fdcc8f
+lib/codeql/rust/elements/Unimplemented.qll 60387a9def0ea3cb9534311ace088106800af0acb89883c5bc9b26d8d8d61718 9d869f83e73915bbeb5af27ea30b69f20c344cd7d7f253cb7dab74de20baa0a6
+lib/codeql/rust/elements/UnimplementedConstructor.qll ee024d4944aebe619ee3ea0ce4f84da0f4fca706baed250c8a65464a8d77979a f95966e3a63cbf2b466241f55bb47c23125645fad206ebd758236465afa4f97d
+lib/codeql/rust/elements/UnsafeBlockExpr.qll d708ee1e3e238fc0bc51b045d8364a1f0fd174570c1e6416242f79655d1c1e38 8f67954791bbe9e127ddd4ada533ba97f5cfac9894a979410366b6747fdd4519
+lib/codeql/rust/elements/UnsafeBlockExprConstructor.qll a089d89cb8f9542b3ee94c8eb7ca9ce0ced08c954802b26826f6aff12f8705dd d3919a40e13d97c48b19df647851f120b667300864d3a2178b1b01236c2dcbd4
+lib/codeql/rust/elements/WildPat.qll 9791bcd2b36516da82a81c10655fe6b4ef0f788d548cc99cb88578dd9c1278f0 03c192da4f92db637001854f904f5f0ea7406b74c02c1ce26cd375d9cfb26108
+lib/codeql/rust/elements/WildPatConstructor.qll 538cde83119510e0b3fc9728127cbf980d17f7f4a9371b4572de26329ab08341 66b96aee3862d5c314a2fbcc6930258f755189c4359394b432e8edb13a9d0eaf
+lib/codeql/rust/elements/YeetExpr.qll 04a1f4f7b2bb697e30ab284720ed30c0c8e1377cacf787383518da1e882f3bd6 277a751f38830e92deb0abcde9cbd124bffc84b7d5a1bacb4f1844c6ebceb2ba
+lib/codeql/rust/elements/YeetExprConstructor.qll f1871c6e0c966c52806e370dbe2956585bbfa1dcf0bd7ebfdb2bd39b7cfd0d7b a2333e80a325a921a66c34151401da12c250951952ccb0c81e5102dc62299503
+lib/codeql/rust/elements/YieldExpr.qll b0f238ba2e4b83b449b44224d766b6cf6b15523a413467f608f4a711d34edc01 355fcafe43915d69a07725ec3707e66abfefc6157bd7dc1c1fd846a965c6580d
+lib/codeql/rust/elements/YieldExprConstructor.qll ff46ba17cc24abfcb0e310c7458d0539b704e7a771ad00853bd3a1844e4e6f82 1c13662ef01c88f1cf057d099eb46524036133e51a0e36ddf947f727ac6046bb
+lib/codeql/rust/elements.qll c0e6bff934b1925ec03e55afc2b5b9127f51dc4a613e047e687bc83cdab4f196 c0e6bff934b1925ec03e55afc2b5b9127f51dc4a613e047e687bc83cdab4f196
+lib/codeql/rust/generated/ArrayExpr.qll b9778720acf4080c065897ba1471be185c0c35f3ea01c15594c0a3ee4029b231 cbc8c9dbcb805063c4b893e21ed0bf00312490a0c92ee126d49dbfff6978fa99
+lib/codeql/rust/generated/AstNode.qll 0598fac7859906f4103124270dfb2fbdb838387b1c45000bf50a4b62c797ec41 f47c84878c7c9676109e358073bddab92a1dbeb4d977d236ecc1eae44d81c894
+lib/codeql/rust/generated/AsyncBlockExpr.qll 1e9d3bcd5d5703bf61748f2746d3f9a4e2a12080268b29a2685b762d13c30555 1e9d3bcd5d5703bf61748f2746d3f9a4e2a12080268b29a2685b762d13c30555
+lib/codeql/rust/generated/AwaitExpr.qll 4b5fccfee29fe28dc85df19b4e6677bf565dacba92a0984bb7ca444650852970 0c0be7ea53e41c7708aa84b93d037fa9df2f72e5a676d78e217ca006f21b548f
+lib/codeql/rust/generated/BecomeExpr.qll a4cde707b7372dd4c48f9b4a450b6ea710085f323878fc17c58f92cf7d50fef9 44f0fa714080eaf6dfe9fecc422b1aa161375b73eb5536ef8bb40b793d8f48ab
+lib/codeql/rust/generated/BinaryOpExpr.qll fe0a286df10f5eaaaba60c74dfc5ef2c17736f24aadb718271e8a17eae736ba1 1f13e04bd6089b956db807e5e0ab974382ef7b5a7271f290a7ae5f75a857a30c
+lib/codeql/rust/generated/BindPat.qll 15d3a33c5f56f7659a331f72735f00930fddd6066659e54c5c19d5e7eb8ef078 bc0a916622b2c426b71760caf15b8e005eed276e06e04d04cc5f19f4c31c34f6
+lib/codeql/rust/generated/BlockExpr.qll baf05a376d4c65505d3aa52eb893e1d8d02a8ef8b16bb40d4a59ee10c7d97b5f 789eccc236d0b4d3adf3dcde699a5f3097d333514455776f74b9184aa14fddb0
+lib/codeql/rust/generated/BlockExprBase.qll f651ce968170b6e05e555924f8004d55b85ff0ae59bce4fea0804691cef0cf66 6ece8056e83d047fc27cdf1110fac166c0d1ba0e26a8d4a7a7cffc05bd6b3b42
+lib/codeql/rust/generated/BoxExpr.qll 880f550a9a6c861efc6310a72830a50bbfdb11982e99f11b5d3f4c6d1fbe826d 380f021014738c86e5745b3320e65a8147ceb30511aa51526a7fab4278a1ecdc
+lib/codeql/rust/generated/BoxPat.qll b69ba2bc341a1bf4c613279e45fb97a530619d4148d5ccc4f05436a316db29eb bf52730243bd1836d5890c745232aba50544c2046d00e80e7d22eebcd104f821
+lib/codeql/rust/generated/BreakExpr.qll d68990513e0b2c0021cccebcdc7dc9ecc1d5b5c7dd0df7014686d6ed8a909940 36875ae186581f10485c1c846c9f6d2bffea3b18375b7f05c2927ba23f08b6ef
+lib/codeql/rust/generated/CallExpr.qll 3e29dc45480e3be1989c364bad0ff94deb322cff20e87a3378fc1a7e11237d61 3873462b8811c3e3ef92700045ed05f55869d320ac74eb72111776d3353095f2
+lib/codeql/rust/generated/CastExpr.qll 6ed07afb453706874d7ae7c4bb09ed35ffdd11e7aeb4cbef4d84dad11a203d0f 741d1c0ff092dc9273b0d588aea6b30f7e2c1c5b9d08f2c4722fe26c2cab33ab
+lib/codeql/rust/generated/ClosureExpr.qll f0c7ce7aecc9da9663cbda3e285be73b23464f8baa6b966fb5aebb0bd0f0aca6 685d74b6a94052fc45aff83b7c525a83f9dfcc02c1bf7e7f7a0aed51ce2de945
+lib/codeql/rust/generated/ConstBlockPat.qll d0818fe4cee066f1e6d3439c82122942ae62941e69da686b7d5c399e820c395c 2fae5a2f0457bb7106d52ac7457afb597d7ac9658b8dcff8e76294f5fe34019a
+lib/codeql/rust/generated/ConstExpr.qll dd851fb049429fe965569beb75957a6a596137b333a6cd7cd588d1c4d40412c4 824825bc46a393827d5df5ae30f622ef2a053ea1f5e338c3b957625a8542cfa5
+lib/codeql/rust/generated/ContinueExpr.qll 436847767d2f68f95d011df0eb8a175924c029ac747daf620a203596479b20b3 e362f28dde0bf3e6ff3b234e81a44bc5026b4c9ed38b8b7872954cca9565eece
+lib/codeql/rust/generated/DbFile.qll 4dbf1931124291e0d6a958ae882f8aeef006642f72adc7ff86cffd3a4e9a970a 4dbf1931124291e0d6a958ae882f8aeef006642f72adc7ff86cffd3a4e9a970a
+lib/codeql/rust/generated/DbLocation.qll 735d9351b5eb46a3231b528600dddec3a4122c18c210d4d632a8d4ceaf7f02e9 735d9351b5eb46a3231b528600dddec3a4122c18c210d4d632a8d4ceaf7f02e9
+lib/codeql/rust/generated/Declaration.qll bbf5ba3792797a829b0032c41fa99d22c26e4277d655099912cdbafb80f0c8cd c4666a71099b21ad5cd83ef6f991ba18f9bef03b3ffbcedfa10aec081d6501d5
+lib/codeql/rust/generated/Element.qll 21567fa7348dccdf69dd34e73cb6de7cc9c7e0f3f7bb419a1abd787f7dc851a1 21567fa7348dccdf69dd34e73cb6de7cc9c7e0f3f7bb419a1abd787f7dc851a1
+lib/codeql/rust/generated/ElementListExpr.qll 3f7e9c1f7249f7283406d2e59b00af750b6dea93b284d7f25af66fe4b3345fea d340242d6072e274fbafd6ff2a5455bf53b3b77ed91539e91563d67cf2ed48f0
+lib/codeql/rust/generated/Expr.qll 32cdd43d17e8b2fb7c73ec723eba89704d1e853e29d304db5eea3979fcdd2e0b 0b8382b0659afa1bd1d13d0cd492d7fbdc0fd7a5162fa658ca2973bc15ee6534
+lib/codeql/rust/generated/ExprStmt.qll f35543fe1481f768eb8abe3fd0d36e2dedf00f0d1adbc31562e6280ef291d0b6 0663097b4b539c5f35dab9b26ab55baee879c7ef543810581347a8951aee46d9
+lib/codeql/rust/generated/FieldExpr.qll 25dd7f15ee3fe1b0de4371cab9df83d3713c1612501e5496c9a15df8d093a755 3c75b0136d1849f6de1bbd14bda4285c52d51c8a6427984c7e5302c05d706e99
+lib/codeql/rust/generated/File.qll 2eff5c882d044d2e360fe6382fb55e5a45f6ccb9df323cfa1fae41eae9d2a47f 87e7a906b3a1b4de056952e288ddd7f69fa7cb1bd9dc7dd3972868a9002ac1e4
+lib/codeql/rust/generated/Function.qll 84a00eb88479efdfe70fe51c3b5cb27ae64a54b48dcca1f2e02f68691b7d907a cde5b965ab27e811f0d24eb4f12bca90c3e8aec3a4c1d9b8bd0023745dfab105
+lib/codeql/rust/generated/IfExpr.qll 7d8e5bd93bb8eda6d5d6551431b0389a2ec5893bd8c13276205d6677856c8341 935bf1be8f790a52e71a6a28456f2f1a5c5cbe6e64bf20fa8602980560899835
+lib/codeql/rust/generated/IndexExpr.qll d44004268aa2e7d79e29133eb593d748beef1d4612318ef469220b3c2252a057 86892c04c59936d33f0cfd5272a04a6ef726f477c2e8f4ef27dae7240af9c804
+lib/codeql/rust/generated/InlineAsmExpr.qll 246c4f255d963f20c8e71fdbd16b4555cb6243820da1d399543205010368ccaa 1ebe22203305195259963bfb90f9928a4255cae993067f6a6fcfbc62069e1b1a
+lib/codeql/rust/generated/ItemStmt.qll b4d2a06fdd00ea90eed2742bacf0a5781b8ad69e24df794ec075d7305220afaa b4d2a06fdd00ea90eed2742bacf0a5781b8ad69e24df794ec075d7305220afaa
+lib/codeql/rust/generated/Label.qll 7de504ea71f2847e305ab5ea3b30403cb0aafbaa0eb4cff3956a2931da6c024b 61e3c6a74b573aadcccefe0d4abe5d8e2542b1e5116c95f4e595b36efa3a86dc
+lib/codeql/rust/generated/LetExpr.qll 896efc732db1ddc8be7281408dfeaf6f04f29d25ee1240738246e0cb31dfc2aa 14d5add4367164f4aa994cd2ae006e8b5918265dade20b41f363daf9537c6d7b
+lib/codeql/rust/generated/LetStmt.qll 1f8fda11b71689fb1a1b9b25a2ce046c56f36f26cddb354805bd395a03e4db3d 80ad6ea6afb1891a02db434cfefdb95b0fb7d766af6246ff27129dc15cb48ace
+lib/codeql/rust/generated/LitPat.qll 92c3c0f32ab9d5b08e246231e5465fe18536dee99351f73e158048bb007baf8a 6736a7824e5bdb0cc16de1231bdb5169d2f48251d5917bf2c31a36422b0bf2fd
+lib/codeql/rust/generated/LiteralExpr.qll 9202e11f56a2c5e99fb98ed784c7ca043c1f5d80680b48ba4ea340dd689ebe55 9202e11f56a2c5e99fb98ed784c7ca043c1f5d80680b48ba4ea340dd689ebe55
+lib/codeql/rust/generated/Locatable.qll 9e9685bba50ad2220701f3465e63af9331f7f9dc548ad906ff954fc2ce0a4400 78c89b2cc78a357d682ab65310dd474603071f07c1eaaab07711714ce17549f2
+lib/codeql/rust/generated/Location.qll bce4c72988ec6fedd1439c60a37c45aa6147c962904709ef9f12206937174be4 d57000571771a2d997c50d9a43ef1c2f075960f847effa0e80ea91fd4c6b4d6c
+lib/codeql/rust/generated/LoopExpr.qll e9304e282a97984e147b92ec7061c98fde238a8691e945e4cb775ccf34c27b0c 65b859e44e83bddb710d4ce9e5ab1346b98eaaa46509671776b75c9e8f1c1667
+lib/codeql/rust/generated/MatchArm.qll 5ad0dc254b6d58ccd856e4235b68ca0226a898c33f1f6b6fe7b48266a01ca627 f519af39f45e820eb3a70cefb0e4dfb541c3cf17952c00c6dd7e59f854a629bd
+lib/codeql/rust/generated/MatchExpr.qll f8b422699337324c91ec9c55024630efe114ca617f4f088a18d180df132d5754 13169bde872f533f55aa196d7150761857c593a4657ab34051346dde14e736c7
+lib/codeql/rust/generated/MethodCallExpr.qll 499fa4c78bafbb8f3a6af645c26f1645c9a634976d409493d26d82dddd4b42a3 2dd18cb4868e96e38383c4ae3f8777637422e90b2363bb533f0e9e1c2692dc6e
+lib/codeql/rust/generated/MissingExpr.qll 90b164567620c88b8e258fa229633365400abeafa4f4b0fcd1c856efc2f9b206 90b164567620c88b8e258fa229633365400abeafa4f4b0fcd1c856efc2f9b206
+lib/codeql/rust/generated/MissingPat.qll 0d8034cee20bacf07ebb9337c797f53a25686a149f163f801916cd6ec5484710 0d8034cee20bacf07ebb9337c797f53a25686a149f163f801916cd6ec5484710
+lib/codeql/rust/generated/Module.qll 2a931a4f2cdb2fee00ed83af045ea63d36b7dbd708e58c30445b5610feaae333 cd62add5c31a509f965aa294f44a1607ec7c62e3a9e3fe9ee063b3c814f4eb62
+lib/codeql/rust/generated/OffsetOfExpr.qll 58dfd632efcb48de7fe6ffbcb2192fcf95bfabdb407a751133f63a0e32ae7489 21ebb1b3d66849fc21c04083cfa751eb56c55809cd52664020bd61ccfbe5ea68
+lib/codeql/rust/generated/OrPat.qll f8fe5c7b83a08dabcc530484a696274930040ea13501ae20f1426faeec67bcf0 f3adb3148890531b698570a48740335983a5e81977ba4ac651778f940f184398
+lib/codeql/rust/generated/ParentChild.qll 956f55ac17d66926c59f76d391b75c30767d236b145d6ae402f4308fa22a7d01 dd3cabb5b4a9ba42be60345f445cde18b0d7be934aeb94d7312eeef122e148d2
+lib/codeql/rust/generated/Pat.qll fe1c72856442dbab5655eff93f86c2cbce8d69d9fa1f99a0f9203061ea1112a4 d85d86e8b6c48df733589d186f610b1cd9086629180701e017774bddc62402c7
+lib/codeql/rust/generated/PathExpr.qll 3664ed2ad08097e4446b0fdad148118c754f8203541ae588d967ba9d79b6bf21 0d987d2358fe9b42e57585e7ae906de80e9f4ccf7c20e1d9bb7624ffbad96941
+lib/codeql/rust/generated/PathPat.qll acc4dda795bae97626a8d0041538f3ba1f0b591c743fed381cf198a8b04653cb c3deee1b3bb9bd37ae3ed4761d8ee2f498384fe5e1f5e31c0f9b99dfd864a0d5
+lib/codeql/rust/generated/PureSynthConstructors.qll 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573 5eb1fc4f6a04172c34ae31e4931e4bf1f8b72fbe414c5f644731a45372d13573
+lib/codeql/rust/generated/RangeExpr.qll f499d8c1f260d6262a55c1f3640aaee832ed8c9aac922cb2e05fefbca4509053 a01563640bc23fbce9d33da756bc209fd16155dc76a7fed4ba325979723f48a5
+lib/codeql/rust/generated/RangePat.qll 6ec95f6cb9c4bd93b38990bb1e3b89b526624305ac6ee7b94e6fb0a2f3db28fc 0e193f3816a7587d5103dba421bc2bf22b869522353d4e3f43d49a792eac6cf4
+lib/codeql/rust/generated/Raw.qll 48d1e7d642bd2a7605dbafe3929c558560054a4e4e3e4b36925a8bfafb7536b9 3b881e64127e9b41fee7e091de725f5cd1cb1263e4a52c02adb1fb339fe36c3d
+lib/codeql/rust/generated/RecordFieldPat.qll 26bed2285d849b9b7ac52d86131eacb40df912db350e423e81fb98c393c08a69 05ed735aecee90901a1bdfae05d9f85d7f6581616eca3a9262fdef6673222f9b
+lib/codeql/rust/generated/RecordLitExpr.qll 1d3264446ff57e8b169f1ad6da150b2d457d6b60eda0ff63e2353eb8ef9e9113 f523dd5ce7f4bac0aafab7b27c6cfe766c72a9ee0c92d7a263347e67edf096df
+lib/codeql/rust/generated/RecordLitField.qll bc704b56a986f3a399dc9c3dc2b61cca0d40cd389c694b9fe13374780835ffcc ab6b05a87f240a97cc2a8c15bb84a1338ad33ce367619125a8514e8815fd050e
+lib/codeql/rust/generated/RecordPat.qll 5fd26e95dd23b07a847bd28c95a4206df62f7cc22c8d7b3bafa10e902e917d15 e264a96c2af4e2f64a394a119329b8b376d4b23ec6a3fc6d123c5631845bc4ef
+lib/codeql/rust/generated/RefExpr.qll bb37b8bff64b0cf1f18de297487455692311b2006c45161f25969e131359c60f bfbc2b67b2b2ec66f3539e4972a947946b29e0ba527042593060eaf6b21e28ad
+lib/codeql/rust/generated/RefPat.qll 3525331e8ba25a8612324e860423a39ddb29e8eb50a9f2bf62e49bf182d64b6d 804efbd32869f92e5515d34852fed6416288f99b0aab95b5be5cb5bdd1eea806
+lib/codeql/rust/generated/RepeatExpr.qll 43aff00e966e4550179d756489e4cbc30618d66c93c13530c45b031b9513b915 b91691445e6f7de67d61c787f41b36a383cf36da1a216c18767ac1d2ce5db34c
+lib/codeql/rust/generated/ReturnExpr.qll 6160f3a14ff1cbd6a297edae015769f90e8e31201639828d8a9d0d6e38c1ef99 b8c8a12f78281e558d230c6959236780758e9645fe22aca697b948535c20f9be
+lib/codeql/rust/generated/SlicePat.qll b4de6692eebf1205940e04da963adc20a07b15923c3c3a7a512a24e3bd8342c9 ee9b919983807f39d97cfe8ca66b76bdbfde76db02db5c93268ce22cbddf4213
+lib/codeql/rust/generated/Stmt.qll 55688c8f42f6e7fd1b871e572d75fac60d0543e38c4be4638abbb00187651d3d f978006a8453137f989249e849a7c935a090da3a9b0116145da80068760e12fd
+lib/codeql/rust/generated/Synth.qll 03ecd0d7e89aca555d2393bbea8de1cde0476e28fb9f198ed3355a74f1b5c1c8 11855cc446c2d8a77503795a7c395e86ff149ea10d773a6e50e54b08dd438642
+lib/codeql/rust/generated/SynthConstructors.qll 07106a119dcfc7a839454d1fa66c0e65d6ab17eeace40cd5bc857a65dc7c859b 07106a119dcfc7a839454d1fa66c0e65d6ab17eeace40cd5bc857a65dc7c859b
+lib/codeql/rust/generated/TupleExpr.qll 13e4dbc1afcabf388c793145cd399789f4014662f2eed1d49cbe96eeb8355413 bfa0708885c120bad24e29deb29641c69a5e5361654f3a144ead9543bfbd7197
+lib/codeql/rust/generated/TuplePat.qll 23911b2ac7ee2279df8ef40a6e447437ef0ed62518504b17874a7652bf5e3f4b fc4f6f7ea40754290de194ac55939f08549bd637104baf8dc84ca3938bcbd1f1
+lib/codeql/rust/generated/TupleStructPat.qll fff004cce780501eac94fe4b146619a84e02c85cae12ffeba5a4058e8c9738ea 738659f8208aa65d1d8cf601e0d92a90a890d6cbaec51cf04c81fc75a827e30b
+lib/codeql/rust/generated/TypeRef.qll 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533 7cc468c2f473ee13c11a97c4360100376560e8fc42f25a136f1500fe31a31533
+lib/codeql/rust/generated/UnaryOpExpr.qll fd55d4bc9cd1a49d1f38f02fef16771f29bb5fb2512abd18341d56665859d18c f271ef5036410c018f48d6f15b17cb9beaf4111a42fc638ac4ed3db974a5f870
+lib/codeql/rust/generated/UnderscoreExpr.qll cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d cd7f615e41562b80d89e413c1c808048da7746fd445f0eb6ad8c5d9996b44d5d
+lib/codeql/rust/generated/Unimplemented.qll 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113 375b7935b7f4103728ece3042282ae82d19e471d7a9fa58c8cbdea31ea0cb113
+lib/codeql/rust/generated/UnknownFile.qll ec9d1a3f15ecbf1743d4e39cb3b2f217aa9b54951c93302c2c4c238c3f0ce595 ec9d1a3f15ecbf1743d4e39cb3b2f217aa9b54951c93302c2c4c238c3f0ce595
+lib/codeql/rust/generated/UnknownLocation.qll a19e2838c52d702d268ae530f3dbd6fcd8bb28a237a52636a960f225454103cf a19e2838c52d702d268ae530f3dbd6fcd8bb28a237a52636a960f225454103cf
+lib/codeql/rust/generated/UnsafeBlockExpr.qll 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e
+lib/codeql/rust/generated/WildPat.qll 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8
+lib/codeql/rust/generated/YeetExpr.qll 2b37cf55ec26958cf226885e99d81c8bbc6ece69fbe92d9fcc8884ee0bc4aad4 e371531507311ea8a9fbaac74442fe9994ae85f0acdb79cc870e5318af52aba9
+lib/codeql/rust/generated/YieldExpr.qll 70ca98e14b24f12a3cbfe690417543fdce45b162f241834e2f7f58543aa11bda 40fe1281107317a7d80c7141229eed9c6904805dff615dfd0141ede2457e2c57
+test/extractor-tests/generated/Expr/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/File/File.ql dec43be882fad904fab0c6447ca93633d801cb08ff8bec309befde7d2b9e5dda 74e1f1d698558c35fa03935cc34f4c8145d376b56d7657b18aeb338f5ca752cf
+test/extractor-tests/generated/Function/Function.ql c49434420dbb6fc3d9e6294161dcd3d3b306fae5ba5c85b610e534b8b15ef74c fe02208b673b74eebed92b5cbb3a8a06c31c0681eb28f3e596515663f14fa9e2
+test/extractor-tests/generated/Module/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/Pat/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/RecordFieldPat/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/RecordLitField/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/Stmt/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
+test/extractor-tests/generated/TypeRef/MISSING_SOURCE.txt cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e cc7c395e7c651d62596826b1a0bedf10f35d01b8afeef47600b4ddaf804f406e
--- a/rust/ql/.gitattributes
+++ b/rust/ql/.gitattributes
@@ -0,0 +1,225 @@
+/.generated.list linguist-generated
+/.gitattributes linguist-generated
+/lib/codeql/rust/elements/ArrayExpr.qll linguist-generated
+/lib/codeql/rust/elements/AstNode.qll linguist-generated
+/lib/codeql/rust/elements/AsyncBlockExpr.qll linguist-generated
+/lib/codeql/rust/elements/AsyncBlockExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/AwaitExpr.qll linguist-generated
+/lib/codeql/rust/elements/AwaitExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BecomeExpr.qll linguist-generated
+/lib/codeql/rust/elements/BecomeExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BinaryOpExpr.qll linguist-generated
+/lib/codeql/rust/elements/BinaryOpExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BindPat.qll linguist-generated
+/lib/codeql/rust/elements/BindPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BlockExpr.qll linguist-generated
+/lib/codeql/rust/elements/BlockExprBase.qll linguist-generated
+/lib/codeql/rust/elements/BlockExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BoxExpr.qll linguist-generated
+/lib/codeql/rust/elements/BoxExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BoxPat.qll linguist-generated
+/lib/codeql/rust/elements/BoxPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/BreakExpr.qll linguist-generated
+/lib/codeql/rust/elements/BreakExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/CallExpr.qll linguist-generated
+/lib/codeql/rust/elements/CallExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/CastExpr.qll linguist-generated
+/lib/codeql/rust/elements/CastExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ClosureExpr.qll linguist-generated
+/lib/codeql/rust/elements/ClosureExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ConstBlockPat.qll linguist-generated
+/lib/codeql/rust/elements/ConstBlockPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ConstExpr.qll linguist-generated
+/lib/codeql/rust/elements/ConstExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ContinueExpr.qll linguist-generated
+/lib/codeql/rust/elements/ContinueExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/DbFile.qll linguist-generated
+/lib/codeql/rust/elements/DbFileConstructor.qll linguist-generated
+/lib/codeql/rust/elements/DbLocation.qll linguist-generated
+/lib/codeql/rust/elements/DbLocationConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Declaration.qll linguist-generated
+/lib/codeql/rust/elements/ElementListExpr.qll linguist-generated
+/lib/codeql/rust/elements/ElementListExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Expr.qll linguist-generated
+/lib/codeql/rust/elements/ExprStmt.qll linguist-generated
+/lib/codeql/rust/elements/ExprStmtConstructor.qll linguist-generated
+/lib/codeql/rust/elements/FieldExpr.qll linguist-generated
+/lib/codeql/rust/elements/FieldExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/FunctionConstructor.qll linguist-generated
+/lib/codeql/rust/elements/IfExpr.qll linguist-generated
+/lib/codeql/rust/elements/IfExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/IndexExpr.qll linguist-generated
+/lib/codeql/rust/elements/IndexExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/InlineAsmExpr.qll linguist-generated
+/lib/codeql/rust/elements/InlineAsmExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ItemStmt.qll linguist-generated
+/lib/codeql/rust/elements/ItemStmtConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Label.qll linguist-generated
+/lib/codeql/rust/elements/LabelConstructor.qll linguist-generated
+/lib/codeql/rust/elements/LetExpr.qll linguist-generated
+/lib/codeql/rust/elements/LetExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/LetStmt.qll linguist-generated
+/lib/codeql/rust/elements/LetStmtConstructor.qll linguist-generated
+/lib/codeql/rust/elements/LitPat.qll linguist-generated
+/lib/codeql/rust/elements/LitPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/LiteralExpr.qll linguist-generated
+/lib/codeql/rust/elements/LiteralExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/LoopExpr.qll linguist-generated
+/lib/codeql/rust/elements/LoopExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/MatchArm.qll linguist-generated
+/lib/codeql/rust/elements/MatchArmConstructor.qll linguist-generated
+/lib/codeql/rust/elements/MatchExpr.qll linguist-generated
+/lib/codeql/rust/elements/MatchExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/MethodCallExpr.qll linguist-generated
+/lib/codeql/rust/elements/MethodCallExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/MissingExpr.qll linguist-generated
+/lib/codeql/rust/elements/MissingExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/MissingPat.qll linguist-generated
+/lib/codeql/rust/elements/MissingPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Module.qll linguist-generated
+/lib/codeql/rust/elements/ModuleConstructor.qll linguist-generated
+/lib/codeql/rust/elements/OffsetOfExpr.qll linguist-generated
+/lib/codeql/rust/elements/OffsetOfExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/OrPat.qll linguist-generated
+/lib/codeql/rust/elements/OrPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Pat.qll linguist-generated
+/lib/codeql/rust/elements/PathExpr.qll linguist-generated
+/lib/codeql/rust/elements/PathExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/PathPat.qll linguist-generated
+/lib/codeql/rust/elements/PathPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RangeExpr.qll linguist-generated
+/lib/codeql/rust/elements/RangeExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RangePat.qll linguist-generated
+/lib/codeql/rust/elements/RangePatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RecordFieldPat.qll linguist-generated
+/lib/codeql/rust/elements/RecordFieldPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RecordLitExpr.qll linguist-generated
+/lib/codeql/rust/elements/RecordLitExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RecordLitField.qll linguist-generated
+/lib/codeql/rust/elements/RecordLitFieldConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RecordPat.qll linguist-generated
+/lib/codeql/rust/elements/RecordPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RefExpr.qll linguist-generated
+/lib/codeql/rust/elements/RefExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RefPat.qll linguist-generated
+/lib/codeql/rust/elements/RefPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/RepeatExpr.qll linguist-generated
+/lib/codeql/rust/elements/RepeatExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/ReturnExpr.qll linguist-generated
+/lib/codeql/rust/elements/ReturnExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/SlicePat.qll linguist-generated
+/lib/codeql/rust/elements/SlicePatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Stmt.qll linguist-generated
+/lib/codeql/rust/elements/TupleExpr.qll linguist-generated
+/lib/codeql/rust/elements/TupleExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/TuplePat.qll linguist-generated
+/lib/codeql/rust/elements/TuplePatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/TupleStructPat.qll linguist-generated
+/lib/codeql/rust/elements/TupleStructPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/TypeRef.qll linguist-generated
+/lib/codeql/rust/elements/TypeRefConstructor.qll linguist-generated
+/lib/codeql/rust/elements/UnaryOpExpr.qll linguist-generated
+/lib/codeql/rust/elements/UnaryOpExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/UnderscoreExpr.qll linguist-generated
+/lib/codeql/rust/elements/UnderscoreExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/Unimplemented.qll linguist-generated
+/lib/codeql/rust/elements/UnimplementedConstructor.qll linguist-generated
+/lib/codeql/rust/elements/UnsafeBlockExpr.qll linguist-generated
+/lib/codeql/rust/elements/UnsafeBlockExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/WildPat.qll linguist-generated
+/lib/codeql/rust/elements/WildPatConstructor.qll linguist-generated
+/lib/codeql/rust/elements/YeetExpr.qll linguist-generated
+/lib/codeql/rust/elements/YeetExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements/YieldExpr.qll linguist-generated
+/lib/codeql/rust/elements/YieldExprConstructor.qll linguist-generated
+/lib/codeql/rust/elements.qll linguist-generated
+/lib/codeql/rust/generated/ArrayExpr.qll linguist-generated
+/lib/codeql/rust/generated/AstNode.qll linguist-generated
+/lib/codeql/rust/generated/AsyncBlockExpr.qll linguist-generated
+/lib/codeql/rust/generated/AwaitExpr.qll linguist-generated
+/lib/codeql/rust/generated/BecomeExpr.qll linguist-generated
+/lib/codeql/rust/generated/BinaryOpExpr.qll linguist-generated
+/lib/codeql/rust/generated/BindPat.qll linguist-generated
+/lib/codeql/rust/generated/BlockExpr.qll linguist-generated
+/lib/codeql/rust/generated/BlockExprBase.qll linguist-generated
+/lib/codeql/rust/generated/BoxExpr.qll linguist-generated
+/lib/codeql/rust/generated/BoxPat.qll linguist-generated
+/lib/codeql/rust/generated/BreakExpr.qll linguist-generated
+/lib/codeql/rust/generated/CallExpr.qll linguist-generated
+/lib/codeql/rust/generated/CastExpr.qll linguist-generated
+/lib/codeql/rust/generated/ClosureExpr.qll linguist-generated
+/lib/codeql/rust/generated/ConstBlockPat.qll linguist-generated
+/lib/codeql/rust/generated/ConstExpr.qll linguist-generated
+/lib/codeql/rust/generated/ContinueExpr.qll linguist-generated
+/lib/codeql/rust/generated/DbFile.qll linguist-generated
+/lib/codeql/rust/generated/DbLocation.qll linguist-generated
+/lib/codeql/rust/generated/Declaration.qll linguist-generated
+/lib/codeql/rust/generated/Element.qll linguist-generated
+/lib/codeql/rust/generated/ElementListExpr.qll linguist-generated
+/lib/codeql/rust/generated/Expr.qll linguist-generated
+/lib/codeql/rust/generated/ExprStmt.qll linguist-generated
+/lib/codeql/rust/generated/FieldExpr.qll linguist-generated
+/lib/codeql/rust/generated/File.qll linguist-generated
+/lib/codeql/rust/generated/Function.qll linguist-generated
+/lib/codeql/rust/generated/IfExpr.qll linguist-generated
+/lib/codeql/rust/generated/IndexExpr.qll linguist-generated
+/lib/codeql/rust/generated/InlineAsmExpr.qll linguist-generated
+/lib/codeql/rust/generated/ItemStmt.qll linguist-generated
+/lib/codeql/rust/generated/Label.qll linguist-generated
+/lib/codeql/rust/generated/LetExpr.qll linguist-generated
+/lib/codeql/rust/generated/LetStmt.qll linguist-generated
+/lib/codeql/rust/generated/LitPat.qll linguist-generated
+/lib/codeql/rust/generated/LiteralExpr.qll linguist-generated
+/lib/codeql/rust/generated/Locatable.qll linguist-generated
+/lib/codeql/rust/generated/Location.qll linguist-generated
+/lib/codeql/rust/generated/LoopExpr.qll linguist-generated
+/lib/codeql/rust/generated/MatchArm.qll linguist-generated
+/lib/codeql/rust/generated/MatchExpr.qll linguist-generated
+/lib/codeql/rust/generated/MethodCallExpr.qll linguist-generated
+/lib/codeql/rust/generated/MissingExpr.qll linguist-generated
+/lib/codeql/rust/generated/MissingPat.qll linguist-generated
+/lib/codeql/rust/generated/Module.qll linguist-generated
+/lib/codeql/rust/generated/OffsetOfExpr.qll linguist-generated
+/lib/codeql/rust/generated/OrPat.qll linguist-generated
+/lib/codeql/rust/generated/ParentChild.qll linguist-generated
+/lib/codeql/rust/generated/Pat.qll linguist-generated
+/lib/codeql/rust/generated/PathExpr.qll linguist-generated
+/lib/codeql/rust/generated/PathPat.qll linguist-generated
+/lib/codeql/rust/generated/PureSynthConstructors.qll linguist-generated
+/lib/codeql/rust/generated/RangeExpr.qll linguist-generated
+/lib/codeql/rust/generated/RangePat.qll linguist-generated
+/lib/codeql/rust/generated/Raw.qll linguist-generated
+/lib/codeql/rust/generated/RecordFieldPat.qll linguist-generated
+/lib/codeql/rust/generated/RecordLitExpr.qll linguist-generated
+/lib/codeql/rust/generated/RecordLitField.qll linguist-generated
+/lib/codeql/rust/generated/RecordPat.qll linguist-generated
+/lib/codeql/rust/generated/RefExpr.qll linguist-generated
+/lib/codeql/rust/generated/RefPat.qll linguist-generated
+/lib/codeql/rust/generated/RepeatExpr.qll linguist-generated
+/lib/codeql/rust/generated/ReturnExpr.qll linguist-generated
+/lib/codeql/rust/generated/SlicePat.qll linguist-generated
+/lib/codeql/rust/generated/Stmt.qll linguist-generated
+/lib/codeql/rust/generated/Synth.qll linguist-generated
+/lib/codeql/rust/generated/SynthConstructors.qll linguist-generated
+/lib/codeql/rust/generated/TupleExpr.qll linguist-generated
+/lib/codeql/rust/generated/TuplePat.qll linguist-generated
+/lib/codeql/rust/generated/TupleStructPat.qll linguist-generated
+/lib/codeql/rust/generated/TypeRef.qll linguist-generated
+/lib/codeql/rust/generated/UnaryOpExpr.qll linguist-generated
+/lib/codeql/rust/generated/UnderscoreExpr.qll linguist-generated
+/lib/codeql/rust/generated/Unimplemented.qll linguist-generated
+/lib/codeql/rust/generated/UnknownFile.qll linguist-generated
+/lib/codeql/rust/generated/UnknownLocation.qll linguist-generated
+/lib/codeql/rust/generated/UnsafeBlockExpr.qll linguist-generated
+/lib/codeql/rust/generated/WildPat.qll linguist-generated
+/lib/codeql/rust/generated/YeetExpr.qll linguist-generated
+/lib/codeql/rust/generated/YieldExpr.qll linguist-generated
+/test/extractor-tests/generated/Expr/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/File/File.ql linguist-generated
+/test/extractor-tests/generated/Function/Function.ql linguist-generated
+/test/extractor-tests/generated/Module/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/Pat/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/RecordFieldPat/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/RecordLitField/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/Stmt/MISSING_SOURCE.txt linguist-generated
+/test/extractor-tests/generated/TypeRef/MISSING_SOURCE.txt linguist-generated
--- a/rust/ql/lib/codeql/IDEContextual.qll
+++ b/rust/ql/lib/codeql/IDEContextual.qll
@@ -0,0 +1,16 @@
+/**
+ * Provides shared predicates related to contextual queries in the code viewer.
+ */
+
+private import codeql.rust.elements.File
+private import codeql.util.FileSystem
+
+/**
+ * Returns an appropriately encoded version of a filename `name`
+ * passed by the VS Code extension in order to coincide with the
+ * output of `.getFile()` on locatable entities.
+ */
+cached
+File getFileBySourceArchiveName(string name) {
+  result = IdeContextual<File>::getFileBySourceArchiveName(name)
+}
--- a/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll
@@ -0,0 +1,263 @@
+private import rust
+private import ControlFlowGraph
+private import internal.SuccessorType
+private import internal.ControlFlowGraphImpl as Impl
+private import codeql.rust.generated.Raw
+private import codeql.rust.generated.Synth
+
+final class BasicBlock = BasicBlockImpl;
+
+/**
+ * A basic block, that is, a maximal straight-line sequence of control flow nodes
+ * without branches or joins.
+ */
+private class BasicBlockImpl extends TBasicBlockStart {
+  /** Gets the scope of this basic block. */
+  CfgScope getScope() { result = this.getAPredecessor().getScope() }
+
+  /** Gets an immediate successor of this basic block, if any. */
+  BasicBlock getASuccessor() { result = this.getASuccessor(_) }
+
+  /** Gets an immediate successor of this basic block of a given type, if any. */
+  BasicBlock getASuccessor(SuccessorType t) {
+    result.getFirstNode() = this.getLastNode().getASuccessor(t)
+  }
+
+  /** Gets an immediate predecessor of this basic block, if any. */
+  BasicBlock getAPredecessor() { result.getASuccessor() = this }
+
+  /** Gets an immediate predecessor of this basic block of a given type, if any. */
+  BasicBlock getAPredecessor(SuccessorType t) { result.getASuccessor(t) = this }
+
+  /** Gets the control flow node at a specific (zero-indexed) position in this basic block. */
+  CfgNode getNode(int pos) { bbIndex(this.getFirstNode(), result, pos) }
+
+  /** Gets a control flow node in this basic block. */
+  CfgNode getANode() { result = this.getNode(_) }
+
+  /** Gets the first control flow node in this basic block. */
+  CfgNode getFirstNode() { this = TBasicBlockStart(result) }
+
+  /** Gets the last control flow node in this basic block. */
+  CfgNode getLastNode() { result = this.getNode(this.length() - 1) }
+
+  /** Gets the length of this basic block. */
+  int length() { result = strictcount(this.getANode()) }
+
+  predicate immediatelyDominates(BasicBlock bb) { bbIDominates(this, bb) }
+
+  predicate strictlyDominates(BasicBlock bb) { bbIDominates+(this, bb) }
+
+  predicate dominates(BasicBlock bb) {
+    bb = this or
+    this.strictlyDominates(bb)
+  }
+
+  predicate inDominanceFrontier(BasicBlock df) {
+    this.dominatesPredecessor(df) and
+    not this.strictlyDominates(df)
+  }
+
+  /**
+   * Holds if this basic block dominates a predecessor of `df`.
+   */
+  private predicate dominatesPredecessor(BasicBlock df) { this.dominates(df.getAPredecessor()) }
+
+  BasicBlock getImmediateDominator() { bbIDominates(result, this) }
+
+  predicate strictlyPostDominates(BasicBlock bb) { bbIPostDominates+(this, bb) }
+
+  predicate postDominates(BasicBlock bb) {
+    this.strictlyPostDominates(bb) or
+    this = bb
+  }
+
+  /** Holds if this basic block is in a loop in the control flow graph. */
+  predicate inLoop() { this.getASuccessor+() = this }
+
+  /** Gets a textual representation of this basic block. */
+  string toString() { result = this.getFirstNode().toString() }
+
+  /** Gets the location of this basic block. */
+  Location getLocation() { result = this.getFirstNode().getLocation() }
+}
+
+cached
+private module Cached {
+  /** Internal representation of basic blocks. */
+  cached
+  newtype TBasicBlock = TBasicBlockStart(CfgNode cfn) { startsBB(cfn) }
+
+  /** Holds if `cfn` starts a new basic block. */
+  private predicate startsBB(CfgNode cfn) {
+    not exists(cfn.getAPredecessor()) and exists(cfn.getASuccessor())
+    or
+    cfn.isJoin()
+    or
+    cfn.getAPredecessor().isBranch()
+  }
+
+  /**
+   * Holds if `succ` is a control flow successor of `pred` within
+   * the same basic block.
+   */
+  private predicate intraBBSucc(CfgNode pred, CfgNode succ) {
+    succ = pred.getASuccessor() and
+    not startsBB(succ)
+  }
+
+  /**
+   * Holds if `cfn` is the `i`th node in basic block `bb`.
+   *
+   * In other words, `i` is the shortest distance from a node `bb`
+   * that starts a basic block to `cfn` along the `intraBBSucc` relation.
+   */
+  cached
+  predicate bbIndex(CfgNode bbStart, CfgNode cfn, int i) =
+    shortestDistances(startsBB/1, intraBBSucc/2)(bbStart, cfn, i)
+
+  /**
+   * Holds if the first node of basic block `succ` is a control flow
+   * successor of the last node of basic block `pred`.
+   */
+  private predicate succBB(BasicBlock pred, BasicBlock succ) { succ = pred.getASuccessor() }
+
+  /** Holds if `dom` is an immediate dominator of `bb`. */
+  cached
+  predicate bbIDominates(BasicBlock dom, BasicBlock bb) =
+    idominance(entryBB/1, succBB/2)(_, dom, bb)
+
+  /** Holds if `pred` is a basic block predecessor of `succ`. */
+  private predicate predBB(BasicBlock succ, BasicBlock pred) { succBB(pred, succ) }
+
+  /** Holds if `bb` is an exit basic block that represents normal exit. */
+  private predicate normalExitBB(BasicBlock bb) {
+    bb.getANode().(Impl::AnnotatedExitNode).isNormal()
+  }
+
+  /** Holds if `dom` is an immediate post-dominator of `bb`. */
+  cached
+  predicate bbIPostDominates(BasicBlock dom, BasicBlock bb) =
+    idominance(normalExitBB/1, predBB/2)(_, dom, bb)
+
+  /**
+   * Gets the `i`th predecessor of join block `jb`, with respect to some
+   * arbitrary order.
+   */
+  cached
+  JoinBlockPredecessor getJoinBlockPredecessor(JoinBlock jb, int i) {
+    result =
+      rank[i + 1](JoinBlockPredecessor jbp |
+        jbp = jb.getAPredecessor()
+      |
+        jbp order by JoinBlockPredecessors::getId(jbp), JoinBlockPredecessors::getSplitString(jbp)
+      )
+  }
+}
+
+private import Cached
+
+/** Holds if `bb` is an entry basic block. */
+private predicate entryBB(BasicBlock bb) { bb.getFirstNode() instanceof Impl::EntryNode }
+
+/**
+ * An entry basic block, that is, a basic block whose first node is
+ * an entry node.
+ */
+class EntryBasicBlock extends BasicBlockImpl {
+  EntryBasicBlock() { entryBB(this) }
+
+  override CfgScope getScope() {
+    this.getFirstNode() = any(Impl::EntryNode node | node.getScope() = result)
+  }
+}
+
+/**
+ * An annotated exit basic block, that is, a basic block whose last node is
+ * an annotated exit node.
+ */
+class AnnotatedExitBasicBlock extends BasicBlockImpl {
+  private boolean normal;
+
+  AnnotatedExitBasicBlock() {
+    exists(Impl::AnnotatedExitNode n |
+      n = this.getANode() and
+      if n.isNormal() then normal = true else normal = false
+    )
+  }
+
+  /** Holds if this block represent a normal exit. */
+  final predicate isNormal() { normal = true }
+}
+
+/**
+ * An exit basic block, that is, a basic block whose last node is
+ * an exit node.
+ */
+class ExitBasicBlock extends BasicBlockImpl {
+  ExitBasicBlock() { this.getLastNode() instanceof Impl::ExitNode }
+}
+
+private module JoinBlockPredecessors {
+  private predicate id(Raw::AstNode x, Raw::AstNode y) { x = y }
+
+  private predicate idOfDbAstNode(Raw::AstNode x, int y) = equivalenceRelation(id/2)(x, y)
+
+  // TODO: does not work if fresh ipa entities (`ipa: on:`) turn out to be first of the block
+  private predicate idOf(AstNode x, int y) { idOfDbAstNode(Synth::convertAstNodeToRaw(x), y) }
+
+  int getId(JoinBlockPredecessor jbp) {
+    idOf(jbp.getFirstNode().(Impl::AstCfgNode).getAstNode(), result)
+    or
+    idOf(jbp.(EntryBasicBlock).getScope(), result)
+  }
+
+  string getSplitString(JoinBlockPredecessor jbp) {
+    result = jbp.getFirstNode().(Impl::AstCfgNode).getSplitsString()
+    or
+    not exists(jbp.getFirstNode().(Impl::AstCfgNode).getSplitsString()) and
+    result = ""
+  }
+}
+
+/** A basic block with more than one predecessor. */
+class JoinBlock extends BasicBlockImpl {
+  JoinBlock() { this.getFirstNode().isJoin() }
+
+  /**
+   * Gets the `i`th predecessor of this join block, with respect to some
+   * arbitrary order.
+   */
+  JoinBlockPredecessor getJoinBlockPredecessor(int i) { result = getJoinBlockPredecessor(this, i) }
+}
+
+/** A basic block that is an immediate predecessor of a join block. */
+class JoinBlockPredecessor extends BasicBlockImpl {
+  JoinBlockPredecessor() { this.getASuccessor() instanceof JoinBlock }
+}
+
+/** A basic block that terminates in a condition, splitting the subsequent control flow. */
+class ConditionBlock extends BasicBlockImpl {
+  ConditionBlock() { this.getLastNode().isCondition() }
+
+  /**
+   * Holds if basic block `succ` is immediately controlled by this basic
+   * block with conditional value `s`. That is, `succ` is an immediate
+   * successor of this block, and `succ` can only be reached from
+   * the callable entry point by going via the `s` edge out of this basic block.
+   */
+  pragma[nomagic]
+  predicate immediatelyControls(BasicBlock succ, SuccessorType s) {
+    succ = this.getASuccessor(s) and
+    forall(BasicBlock pred | pred = succ.getAPredecessor() and pred != this | succ.dominates(pred))
+  }
+
+  /**
+   * Holds if basic block `controlled` is controlled by this basic block with
+   * conditional value `s`. That is, `controlled` can only be reached from
+   * the callable entry point by going via the `s` edge out of this basic block.
+   */
+  predicate controls(BasicBlock controlled, BooleanSuccessor s) {
+    exists(BasicBlock succ | this.immediatelyControls(succ, s) | succ.dominates(controlled))
+  }
+}
--- a/rust/ql/lib/codeql/rust/controlflow/ControlFlowGraph.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/ControlFlowGraph.qll
@@ -0,0 +1,38 @@
+/** Provides classes representing the control flow graph. */
+
+private import rust
+private import internal.ControlFlowGraphImpl
+private import internal.Completion
+private import internal.SuccessorType
+private import internal.Scope as Scope
+private import BasicBlocks
+
+final class CfgScope = Scope::CfgScope;
+
+/**
+ * A control flow node.
+ *
+ * A control flow node is a node in the control flow graph (CFG). There is a
+ * many-to-one relationship between CFG nodes and AST nodes.
+ *
+ * Only nodes that can be reached from an entry point are included in the CFG.
+ */
+final class CfgNode extends Node {
+  /** Gets the file of this control flow node. */
+  File getFile() { result = this.getLocation().getFile() }
+
+  /** Gets a successor node of a given type, if any. */
+  CfgNode getASuccessor(SuccessorType t) { result = super.getASuccessor(t) }
+
+  /** Gets an immediate successor, if any. */
+  CfgNode getASuccessor() { result = this.getASuccessor(_) }
+
+  /** Gets an immediate predecessor node of a given flow type, if any. */
+  CfgNode getAPredecessor(SuccessorType t) { result.getASuccessor(t) = this }
+
+  /** Gets an immediate predecessor, if any. */
+  CfgNode getAPredecessor() { result = this.getAPredecessor(_) }
+
+  /** Gets the basic block that this control flow node belongs to. */
+  BasicBlock getBasicBlock() { result.getANode() = this }
+}
--- a/rust/ql/lib/codeql/rust/controlflow/internal/Completion.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/Completion.qll
@@ -0,0 +1,93 @@
+private import codeql.util.Boolean
+private import codeql.rust.controlflow.ControlFlowGraph
+private import rust
+private import SuccessorType
+
+private newtype TCompletion =
+  TSimpleCompletion() or
+  TBooleanCompletion(Boolean b) or
+  TReturnCompletion()
+
+/** A completion of a statement or an expression. */
+abstract class Completion extends TCompletion {
+  /** Gets a textual representation of this completion. */
+  abstract string toString();
+
+  predicate isValidForSpecific(AstNode e) { none() }
+
+  predicate isValidFor(AstNode e) { this.isValidForSpecific(e) }
+
+  /** Gets a successor type that matches this completion. */
+  abstract SuccessorType getAMatchingSuccessorType();
+}
+
+/**
+ * A completion that represents normal evaluation of a statement or an
+ * expression.
+ */
+abstract class NormalCompletion extends Completion { }
+
+/** A simple (normal) completion. */
+class SimpleCompletion extends NormalCompletion, TSimpleCompletion {
+  override NormalSuccessor getAMatchingSuccessorType() { any() }
+
+  // `SimpleCompletion` is the "default" completion type, thus it is valid for
+  // any node where there isn't another more specific completion type.
+  override predicate isValidFor(AstNode e) { not any(Completion c).isValidForSpecific(e) }
+
+  override string toString() { result = "simple" }
+}
+
+/**
+ * A completion that represents evaluation of an expression, whose value
+ * determines the successor.
+ */
+abstract class ConditionalCompletion extends NormalCompletion {
+  boolean value;
+
+  bindingset[value]
+  ConditionalCompletion() { any() }
+
+  /** Gets the Boolean value of this conditional completion. */
+  final boolean getValue() { result = value }
+
+  /** Gets the dual completion. */
+  abstract ConditionalCompletion getDual();
+}
+
+/**
+ * A completion that represents evaluation of an expression
+ * with a Boolean value.
+ */
+class BooleanCompletion extends ConditionalCompletion, TBooleanCompletion {
+  BooleanCompletion() { this = TBooleanCompletion(value) }
+
+  override predicate isValidForSpecific(AstNode e) { e = any(IfExpr c).getCondition() }
+
+  /** Gets the dual Boolean completion. */
+  override BooleanCompletion getDual() { result = TBooleanCompletion(value.booleanNot()) }
+
+  override BooleanSuccessor getAMatchingSuccessorType() { result.getValue() = value }
+
+  override string toString() { result = "boolean(" + value + ")" }
+}
+
+/**
+ * A completion that represents a return.
+ */
+class ReturnCompletion extends TReturnCompletion, Completion {
+  override ReturnSuccessor getAMatchingSuccessorType() { any() }
+
+  override predicate isValidForSpecific(AstNode e) { e instanceof ReturnExpr }
+
+  override string toString() { result = "return" }
+}
+
+/** Hold if `c` represents normal evaluation of a statement or an expression. */
+predicate completionIsNormal(Completion c) { c instanceof NormalCompletion }
+
+/** Hold if `c` represents simple and normal evaluation of a statement or an expression. */
+predicate completionIsSimple(Completion c) { c instanceof SimpleCompletion }
+
+/** Holds if `c` is a valid completion for `n`. */
+predicate completionIsValidFor(Completion c, AstNode n) { c.isValidFor(n) }
--- a/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll
@@ -0,0 +1,129 @@
+private import rust
+import codeql.controlflow.Cfg
+import Completion
+import codeql.controlflow.Cfg
+private import SuccessorType as ST
+private import Scope as Scope
+
+module CfgInput implements InputSig<Location> {
+  private import rust as Rust
+  private import Completion as C
+  private import Splitting as S
+
+  class AstNode = Rust::AstNode;
+
+  class Completion = C::Completion;
+
+  predicate completionIsNormal = C::completionIsNormal/1;
+
+  predicate completionIsSimple = C::completionIsSimple/1;
+
+  predicate completionIsValidFor = C::completionIsValidFor/2;
+
+  /** An AST node with an associated control-flow graph. */
+  class CfgScope = Scope::CfgScope;
+
+  CfgScope getCfgScope(AstNode n) { result = Scope::scopeOfAst(n) }
+
+  class SplitKindBase = S::TSplitKind;
+
+  class Split = S::Split;
+
+  class SuccessorType = ST::SuccessorType;
+
+  /** Gets a successor type that matches completion `c`. */
+  SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
+
+  /**
+   * Hold if `c` represents simple (normal) evaluation of a statement or an expression.
+   */
+  predicate successorTypeIsSimple(SuccessorType t) { t instanceof ST::NormalSuccessor }
+
+  /** Holds if `t` is an abnormal exit type out of a CFG scope. */
+  predicate isAbnormalExitType(SuccessorType t) { none() }
+
+  /** Hold if `t` represents a conditional successor type. */
+  predicate successorTypeIsCondition(SuccessorType t) { t instanceof ST::BooleanSuccessor }
+
+  /** Gets the maximum number of splits allowed for a given node. */
+  int maxSplits() { result = 0 }
+
+  /** Holds if `first` is first executed when entering `scope`. */
+  predicate scopeFirst(CfgScope scope, AstNode first) {
+    scope.(CfgImpl::ControlFlowTree).first(first)
+  }
+
+  /** Holds if `scope` is exited when `last` finishes with completion `c`. */
+  predicate scopeLast(CfgScope scope, AstNode last, Completion c) {
+    scope.(CfgImpl::ControlFlowTree).last(last, c)
+  }
+}
+
+module CfgImpl = Make<Location, CfgInput>;
+
+import CfgImpl
+
+class FunctionTree extends StandardPostOrderTree instanceof Function {
+  override ControlFlowTree getChildNode(int i) { i = 0 and result = super.getBody() }
+}
+
+class BlockExprTree extends StandardPostOrderTree instanceof BlockExpr {
+  override ControlFlowTree getChildNode(int i) {
+    result = super.getStatement(i)
+    or
+    not exists(super.getStatement(i)) and
+    (exists(super.getStatement(i - 1)) or i = 0) and
+    result = super.getTail()
+  }
+}
+
+class CallExprTree extends StandardPostOrderTree instanceof CallExpr {
+  override ControlFlowTree getChildNode(int i) { result = super.getArg(i) }
+}
+
+class BinaryOpExprTree extends StandardPostOrderTree instanceof BinaryOpExpr {
+  override ControlFlowTree getChildNode(int i) {
+    i = 0 and result = super.getLhs()
+    or
+    i = 1 and result = super.getRhs()
+  }
+}
+
+class IfExprTree extends PostOrderTree instanceof IfExpr {
+  override predicate first(AstNode node) { first(super.getCondition(), node) }
+
+  override predicate propagatesAbnormal(AstNode child) {
+    child = [super.getCondition(), super.getThen(), super.getElse()]
+  }
+
+  override predicate succ(AstNode pred, AstNode succ, Completion c) {
+    // Edges from the condition to each branch
+    last(super.getCondition(), pred, c) and
+    (
+      first(super.getThen(), succ) and c.(BooleanCompletion).getValue() = true
+      or
+      first(super.getElse(), succ) and c.(BooleanCompletion).getValue() = false
+    )
+    or
+    // An edge from the then branch to the last node
+    last(super.getThen(), pred, c) and
+    succ = this and
+    completionIsNormal(c)
+    or
+    // An edge from the else branch to the last node
+    last(super.getElse(), pred, c) and
+    succ = this and
+    completionIsNormal(c)
+  }
+}
+
+class LetExprTree extends StandardPostOrderTree instanceof LetExpr {
+  override ControlFlowTree getChildNode(int i) { i = 0 and result = super.getExpr() }
+}
+
+class LiteralExprTree extends LeafTree instanceof LiteralExpr { }
+
+class PathExprTree extends LeafTree instanceof PathExpr { }
+
+// A leaf tree for unimplemented nodes in the AST.
+class UnimplementedTree extends LeafTree instanceof Unimplemented { }
--- a/rust/ql/lib/codeql/rust/controlflow/internal/PrintCfg.ql
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/PrintCfg.ql
@@ -0,0 +1,50 @@
+/**
+ * @name Print CFG
+ * @description Produces a representation of a file's Control Flow Graph.
+ *              This query is used by the VS Code extension.
+ * @id rust/print-cfg
+ * @kind graph
+ * @tags ide-contextual-queries/print-cfg
+ */
+
+private import codeql.rust.elements.File
+private import codeql.rust.controlflow.internal.ControlFlowGraphImpl
+private import codeql.rust.controlflow.ControlFlowGraph
+
+/**
+ * Gets the source file to generate a CFG from.
+ */
+external string selectedSourceFile();
+
+private predicate selectedSourceFileAlias = selectedSourceFile/0;
+
+/**
+ * Gets the source line to generate a CFG from.
+ */
+external int selectedSourceLine();
+
+private predicate selectedSourceLineAlias = selectedSourceLine/0;
+
+/**
+ * Gets the source column to generate a CFG from.
+ */
+external int selectedSourceColumn();
+
+private predicate selectedSourceColumnAlias = selectedSourceColumn/0;
+
+private module ViewCfgQueryInput implements ViewCfgQueryInputSig<File> {
+  predicate selectedSourceFile = selectedSourceFileAlias/0;
+
+  predicate selectedSourceLine = selectedSourceLineAlias/0;
+
+  predicate selectedSourceColumn = selectedSourceColumnAlias/0;
+
+  predicate cfgScopeSpan(
+    CfgScope scope, File file, int startLine, int startColumn, int endLine, int endColumn
+  ) {
+    file = scope.getFile() and
+    scope.getLocation().hasLocationInfo(_, startLine, startColumn, endLine, endColumn)
+  }
+}
+
+import ViewCfgQuery<File, ViewCfgQueryInput>
--- a/rust/ql/lib/codeql/rust/controlflow/internal/Scope.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/Scope.qll
@@ -0,0 +1,32 @@
+private import rust
+private import Completion
+private import codeql.rust.generated.ParentChild
+
+abstract class CfgScope extends AstNode { }
+
+class FunctionScope extends CfgScope, Function { }
+
+/**
+ * Gets the immediate parent of a non-`AstNode` element `e`.
+ *
+ * We restrict `e` to be a non-`AstNode` to skip past non-`AstNode` in
+ * the transitive closure computation in `getParentOfAst`. This is
+ * necessary because the parent of an `AstNode` is not necessarily an `AstNode`.
+ */
+private Element getParentOfAstStep(Element e) {
+  not e instanceof AstNode and
+  result = getImmediateParent(e)
+}
+
+/** Gets the nearest enclosing parent of `ast` that is an `AstNode`. */
+private AstNode getParentOfAst(AstNode ast) {
+  result = getParentOfAstStep*(getImmediateParent(ast))
+}
+
+/** Gets the enclosing scope of a node */
+cached
+AstNode scopeOfAst(AstNode n) {
+  exists(AstNode p | p = getParentOfAst(n) |
+    if p instanceof CfgScope then p = result else result = scopeOfAst(p)
+  )
+}
--- a/rust/ql/lib/codeql/rust/controlflow/internal/Splitting.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/Splitting.qll
@@ -0,0 +1,17 @@
+cached
+private module Cached {
+  // Not using CFG splitting, so the following are just placeholder types.
+  cached
+  newtype TSplitKind = TSplitKindUnit()
+
+  cached
+  newtype TSplit = TSplitUnit()
+}
+
+import Cached
+
+/** A split for a control flow node. */
+class Split extends TSplit {
+  /** Gets a textual representation of this split. */
+  string toString() { none() }
+}
--- a/rust/ql/lib/codeql/rust/controlflow/internal/SuccessorType.qll
+++ b/rust/ql/lib/codeql/rust/controlflow/internal/SuccessorType.qll
@@ -0,0 +1,45 @@
+private import codeql.util.Boolean
+
+cached
+newtype TSuccessorType =
+  TSuccessorSuccessor() or
+  TBooleanSuccessor(Boolean b) or
+  TReturnSuccessor()
+
+/** The type of a control flow successor. */
+abstract private class SuccessorTypeImpl extends TSuccessorType {
+  /** Gets a textual representation of successor type. */
+  abstract string toString();
+}
+
+final class SuccessorType = SuccessorTypeImpl;
+
+/** A normal control flow successor. */
+final class NormalSuccessor extends SuccessorTypeImpl, TSuccessorSuccessor {
+  final override string toString() { result = "successor" }
+}
+
+/** A conditional control flow successor. */
+abstract private class ConditionalSuccessor extends SuccessorTypeImpl {
+  boolean value;
+
+  bindingset[value]
+  ConditionalSuccessor() { any() }
+
+  /** Gets the Boolean value of this successor. */
+  final boolean getValue() { result = value }
+
+  override string toString() { result = this.getValue().toString() }
+}
+
+/** A Boolean control flow successor. */
+final class BooleanSuccessor extends ConditionalSuccessor, TBooleanSuccessor {
+  BooleanSuccessor() { this = TBooleanSuccessor(value) }
+}
+
+/**
+ * A `return` control flow successor.
+ */
+final class ReturnSuccessor extends SuccessorTypeImpl, TReturnSuccessor {
+  final override string toString() { result = "return" }
+}
--- a/rust/ql/lib/codeql/rust/elements.qll
+++ b/rust/ql/lib/codeql/rust/elements.qll
@@ -0,0 +1,81 @@
+// generated by codegen
+/**
+ * This module exports all modules providing `Element` subclasses.
+ */
+
+import codeql.rust.elements.ArrayExpr
+import codeql.rust.elements.AstNode
+import codeql.rust.elements.AsyncBlockExpr
+import codeql.rust.elements.AwaitExpr
+import codeql.rust.elements.BecomeExpr
+import codeql.rust.elements.BinaryOpExpr
+import codeql.rust.elements.BindPat
+import codeql.rust.elements.BlockExpr
+import codeql.rust.elements.BlockExprBase
+import codeql.rust.elements.BoxExpr
+import codeql.rust.elements.BoxPat
+import codeql.rust.elements.BreakExpr
+import codeql.rust.elements.CallExpr
+import codeql.rust.elements.CastExpr
+import codeql.rust.elements.ClosureExpr
+import codeql.rust.elements.ConstBlockPat
+import codeql.rust.elements.ConstExpr
+import codeql.rust.elements.ContinueExpr
+import codeql.rust.elements.DbFile
+import codeql.rust.elements.DbLocation
+import codeql.rust.elements.Declaration
+import codeql.rust.elements.Element
+import codeql.rust.elements.ElementListExpr
+import codeql.rust.elements.Expr
+import codeql.rust.elements.ExprStmt
+import codeql.rust.elements.FieldExpr
+import codeql.rust.elements.File
+import codeql.rust.elements.Function
+import codeql.rust.elements.IfExpr
+import codeql.rust.elements.IndexExpr
+import codeql.rust.elements.InlineAsmExpr
+import codeql.rust.elements.ItemStmt
+import codeql.rust.elements.Label
+import codeql.rust.elements.LetExpr
+import codeql.rust.elements.LetStmt
+import codeql.rust.elements.LitPat
+import codeql.rust.elements.LiteralExpr
+import codeql.rust.elements.Locatable
+import codeql.rust.elements.Location
+import codeql.rust.elements.LoopExpr
+import codeql.rust.elements.MatchArm
+import codeql.rust.elements.MatchExpr
+import codeql.rust.elements.MethodCallExpr
+import codeql.rust.elements.MissingExpr
+import codeql.rust.elements.MissingPat
+import codeql.rust.elements.Module
+import codeql.rust.elements.OffsetOfExpr
+import codeql.rust.elements.OrPat
+import codeql.rust.elements.Pat
+import codeql.rust.elements.PathExpr
+import codeql.rust.elements.PathPat
+import codeql.rust.elements.RangeExpr
+import codeql.rust.elements.RangePat
+import codeql.rust.elements.RecordFieldPat
+import codeql.rust.elements.RecordLitExpr
+import codeql.rust.elements.RecordLitField
+import codeql.rust.elements.RecordPat
+import codeql.rust.elements.RefExpr
+import codeql.rust.elements.RefPat
+import codeql.rust.elements.RepeatExpr
+import codeql.rust.elements.ReturnExpr
+import codeql.rust.elements.SlicePat
+import codeql.rust.elements.Stmt
+import codeql.rust.elements.TupleExpr
+import codeql.rust.elements.TuplePat
+import codeql.rust.elements.TupleStructPat
+import codeql.rust.elements.TypeRef
+import codeql.rust.elements.UnaryOpExpr
+import codeql.rust.elements.UnderscoreExpr
+import codeql.rust.elements.Unimplemented
+import codeql.rust.elements.UnknownFile
+import codeql.rust.elements.UnknownLocation
+import codeql.rust.elements.UnsafeBlockExpr
+import codeql.rust.elements.WildPat
+import codeql.rust.elements.YeetExpr
+import codeql.rust.elements.YieldExpr
--- a/rust/ql/lib/codeql/rust/elements/ArrayExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/ArrayExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ArrayExpr`.
+ */
+
+private import codeql.rust.generated.ArrayExpr
+
+class ArrayExpr extends Generated::ArrayExpr { }
--- a/rust/ql/lib/codeql/rust/elements/AstNode.qll
+++ b/rust/ql/lib/codeql/rust/elements/AstNode.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `AstNode`.
+ */
+
+private import codeql.rust.generated.AstNode
+
+class AstNode extends Generated::AstNode { }
--- a/rust/ql/lib/codeql/rust/elements/AsyncBlockExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/AsyncBlockExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `AsyncBlockExpr`.
+ */
+
+private import codeql.rust.generated.AsyncBlockExpr
+
+class AsyncBlockExpr extends Generated::AsyncBlockExpr { }
--- a/rust/ql/lib/codeql/rust/elements/AsyncBlockExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/AsyncBlockExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `AsyncBlockExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `AsyncBlockExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructAsyncBlockExpr(Raw::AsyncBlockExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/AwaitExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/AwaitExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `AwaitExpr`.
+ */
+
+private import codeql.rust.generated.AwaitExpr
+
+class AwaitExpr extends Generated::AwaitExpr { }
--- a/rust/ql/lib/codeql/rust/elements/AwaitExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/AwaitExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `AwaitExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `AwaitExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructAwaitExpr(Raw::AwaitExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BecomeExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/BecomeExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BecomeExpr`.
+ */
+
+private import codeql.rust.generated.BecomeExpr
+
+class BecomeExpr extends Generated::BecomeExpr { }
--- a/rust/ql/lib/codeql/rust/elements/BecomeExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BecomeExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BecomeExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BecomeExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBecomeExpr(Raw::BecomeExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BinaryOpExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/BinaryOpExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BinaryOpExpr`.
+ */
+
+private import codeql.rust.generated.BinaryOpExpr
+
+class BinaryOpExpr extends Generated::BinaryOpExpr { }
--- a/rust/ql/lib/codeql/rust/elements/BinaryOpExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BinaryOpExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BinaryOpExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BinaryOpExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBinaryOpExpr(Raw::BinaryOpExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BindPat.qll
+++ b/rust/ql/lib/codeql/rust/elements/BindPat.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BindPat`.
+ */
+
+private import codeql.rust.generated.BindPat
+
+class BindPat extends Generated::BindPat { }
--- a/rust/ql/lib/codeql/rust/elements/BindPatConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BindPatConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BindPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BindPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBindPat(Raw::BindPat id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BlockExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/BlockExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BlockExpr`.
+ */
+
+private import codeql.rust.generated.BlockExpr
+
+class BlockExpr extends Generated::BlockExpr { }
--- a/rust/ql/lib/codeql/rust/elements/BlockExprBase.qll
+++ b/rust/ql/lib/codeql/rust/elements/BlockExprBase.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BlockExprBase`.
+ */
+
+private import codeql.rust.generated.BlockExprBase
+
+class BlockExprBase extends Generated::BlockExprBase { }
--- a/rust/ql/lib/codeql/rust/elements/BlockExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BlockExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BlockExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BlockExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBlockExpr(Raw::BlockExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BoxExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/BoxExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BoxExpr`.
+ */
+
+private import codeql.rust.generated.BoxExpr
+
+class BoxExpr extends Generated::BoxExpr { }
--- a/rust/ql/lib/codeql/rust/elements/BoxExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BoxExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BoxExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BoxExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBoxExpr(Raw::BoxExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BoxPat.qll
+++ b/rust/ql/lib/codeql/rust/elements/BoxPat.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BoxPat`.
+ */
+
+private import codeql.rust.generated.BoxPat
+
+class BoxPat extends Generated::BoxPat { }
--- a/rust/ql/lib/codeql/rust/elements/BoxPatConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BoxPatConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BoxPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BoxPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBoxPat(Raw::BoxPat id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/BreakExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/BreakExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `BreakExpr`.
+ */
+
+private import codeql.rust.generated.BreakExpr
+
+class BreakExpr extends Generated::BreakExpr { }
--- a/rust/ql/lib/codeql/rust/elements/BreakExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/BreakExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `BreakExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `BreakExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructBreakExpr(Raw::BreakExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/CallExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/CallExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `CallExpr`.
+ */
+
+private import codeql.rust.generated.CallExpr
+
+class CallExpr extends Generated::CallExpr { }
--- a/rust/ql/lib/codeql/rust/elements/CallExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/CallExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `CallExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `CallExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructCallExpr(Raw::CallExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/CastExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/CastExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `CastExpr`.
+ */
+
+private import codeql.rust.generated.CastExpr
+
+class CastExpr extends Generated::CastExpr { }
--- a/rust/ql/lib/codeql/rust/elements/CastExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/CastExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `CastExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `CastExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructCastExpr(Raw::CastExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/ClosureExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/ClosureExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ClosureExpr`.
+ */
+
+private import codeql.rust.generated.ClosureExpr
+
+class ClosureExpr extends Generated::ClosureExpr { }
--- a/rust/ql/lib/codeql/rust/elements/ClosureExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/ClosureExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `ClosureExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `ClosureExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructClosureExpr(Raw::ClosureExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/ConstBlockPat.qll
+++ b/rust/ql/lib/codeql/rust/elements/ConstBlockPat.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ConstBlockPat`.
+ */
+
+private import codeql.rust.generated.ConstBlockPat
+
+class ConstBlockPat extends Generated::ConstBlockPat { }
--- a/rust/ql/lib/codeql/rust/elements/ConstBlockPatConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/ConstBlockPatConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `ConstBlockPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `ConstBlockPat` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructConstBlockPat(Raw::ConstBlockPat id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/ConstExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/ConstExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ConstExpr`.
+ */
+
+private import codeql.rust.generated.ConstExpr
+
+class ConstExpr extends Generated::ConstExpr { }
--- a/rust/ql/lib/codeql/rust/elements/ConstExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/ConstExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `ConstExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `ConstExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructConstExpr(Raw::ConstExpr id) { any() }
--- a/rust/ql/lib/codeql/rust/elements/ContinueExpr.qll
+++ b/rust/ql/lib/codeql/rust/elements/ContinueExpr.qll
@@ -0,0 +1,8 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ * This module provides a hand-modifiable wrapper around the generated class `ContinueExpr`.
+ */
+
+private import codeql.rust.generated.ContinueExpr
+
+class ContinueExpr extends Generated::ContinueExpr { }
--- a/rust/ql/lib/codeql/rust/elements/ContinueExprConstructor.qll
+++ b/rust/ql/lib/codeql/rust/elements/ContinueExprConstructor.qll
@@ -0,0 +1,14 @@
+// generated by codegen, remove this comment if you wish to edit this file
+/**
+ *  This module defines the hook used internally to tweak the characteristic predicate of
+ *  `ContinueExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `ContinueExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructContinueExpr(Raw::ContinueExpr id) { any() }
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`paths = ["../../shared/tree-sitter-extractor"]`