Merge pull request #17408 from github/aibaars/rust-experiment

Rust: add partial extractor for Expr, Statement, Pattern

rust/codeql-extractor.yml

@@ -13,4 +13,24 @@ file_types:
   - name: rust
     display_name: Rust files
     extensions:
-       - .rs
+      - .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 'brotli' (the default, to write brotli-compressed TRAP), 'gzip', and 'none'
+          (to write uncompressed TRAP).
+        type: string
+        pattern: "^(none|gzip|brotli)$"
+  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)$"

rust/extractor/Cargo.lock

@@ -353,6 +353,7 @@ dependencies = [
  "ra_ap_hir_def",
  "ra_ap_ide_db",
  "ra_ap_load-cargo",
+ "ra_ap_paths",
  "ra_ap_project_model",
  "ra_ap_syntax",
  "ra_ap_vfs",

rust/extractor/Cargo.toml

@@ -16,6 +16,7 @@ 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"

rust/extractor/src/config.rs

@@ -32,6 +32,7 @@ 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>,
@@ -68,10 +69,11 @@ impl Config {
             let inputs_list = std::fs::read_to_string(inputs_file).context("reading file list")?;
             cli_args
                 .inputs
-                .extend(inputs_list.split("\n").map(PathBuf::from));
+                .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")

rust/extractor/src/generated/.generated.list

@@ -1,2 +1,2 @@
 mod.rs 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e 7cdfedcd68cf8e41134daf810c1af78624082b0c3e8be6570339b1a69a5d457e
-top.rs 3e4cef09cd4603b2b741a30ff15e0b175dec5934cc0df7d42aa4c5bdf1dbe5c7 3e4cef09cd4603b2b741a30ff15e0b175dec5934cc0df7d42aa4c5bdf1dbe5c7
+top.rs 569909061b9a993481764765a014327d143939778f2dbc79836e7496cdb83e1f 569909061b9a993481764765a014327d143939778f2dbc79836e7496cdb83e1f

rust/extractor/src/main.rs

@@ -5,6 +5,7 @@ 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;
@@ -14,6 +15,19 @@ 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()
@@ -28,18 +42,26 @@ fn main() -> anyhow::Result<()> {
 
     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| (println!("progress: {}", t));
+    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,
     };
-    for input in cfg.inputs {
-        let (db, vfs, _macro_server) = load_workspace_at(&input, &config, &load_config, &progress)
-            .context("loading inputs")?;
-        _macro_server.expect("no macro server");
+    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);
@@ -56,9 +78,16 @@ fn main() -> anyhow::Result<()> {
                     crate_id.into_raw().into_u32()
                 )),
             );
-            translate::CrateTranslator::new(&db, trap, &krate, &vfs, &archiver)
-                .emit_crate()
-                .context("writing trap file")?;
+            translate::CrateTranslator::new(
+                &db,
+                trap,
+                &krate,
+                &vfs,
+                &archiver,
+                cfg.extract_dependencies,
+            )
+            .emit_crate()
+            .context("writing trap file")?;
         }
     }
     Ok(())

rust/extractor/src/translate.rs

@@ -2,11 +2,19 @@ use crate::archive::Archiver;
 use crate::trap::{AsTrapKeyPart, TrapFile, TrapId};
 use crate::{generated, trap_key};
 use codeql_extractor::trap;
+use ra_ap_hir::db::{DefDatabase, InternDatabase};
 use ra_ap_hir::HasSource;
+use ra_ap_hir::TypeRef;
 use ra_ap_hir::{Crate, Module, ModuleDef};
+use ra_ap_hir_def::body::{Body, BodySourceMap};
+use ra_ap_hir_def::hir::{
+    CaptureBy, ExprId, LabelId, MatchArm, PatId, RecordFieldPat, RecordLitField, Statement,
+};
+use ra_ap_hir_def::path::Path;
 use ra_ap_ide_db::line_index::LineIndex;
 use ra_ap_ide_db::{LineIndexDatabase, RootDatabase};
-use ra_ap_syntax::AstNode;
+use ra_ap_syntax::ast::RangeOp;
+use ra_ap_syntax::{AstNode, Edition, TextRange, TextSize};
 use ra_ap_vfs::{FileId, Vfs};
 use std::collections::HashMap;
 use std::fs;
@@ -24,6 +32,7 @@ pub struct CrateTranslator<'a> {
     krate: &'a Crate,
     vfs: &'a Vfs,
     archiver: &'a Archiver,
+    extract_dependencies: bool,
     file_labels: HashMap<PathBuf, FileData>,
 }
 
@@ -34,6 +43,7 @@ impl CrateTranslator<'_> {
         krate: &'a Crate,
         vfs: &'a Vfs,
         archiver: &'a Archiver,
+        extract_dependencies: bool,
     ) -> CrateTranslator<'a> {
         CrateTranslator {
             db,
@@ -41,6 +51,7 @@ impl CrateTranslator<'_> {
             krate,
             vfs,
             archiver,
+            extract_dependencies,
             file_labels: HashMap::new(),
         }
     }
@@ -64,6 +75,76 @@ impl CrateTranslator<'_> {
         })
     }
 
+    fn emit_location_for_ast_ptr<T>(
+        &mut self,
+        source: ra_ap_hir::InFile<ra_ap_syntax::AstPtr<T>>,
+    ) -> Option<trap::Label>
+    where
+        T: AstNode,
+    {
+        source
+            .file_id
+            .file_id()
+            .map(|f| (f.file_id(), source))
+            .and_then(|(file_id, source)| self.emit_file(file_id).map(|data| (data, source)))
+            .map(|(data, source)| {
+                let range = source.value.text_range();
+                self.emit_location_for_textrange(data, range)
+            })
+    }
+
+    fn emit_location_for_expr(
+        &mut self,
+        expr: ra_ap_hir_def::hir::ExprId,
+        source_map: &BodySourceMap,
+    ) -> Option<trap::Label> {
+        let source = source_map.expr_syntax(expr).ok()?;
+        self.emit_location_for_ast_ptr(source)
+    }
+
+    fn emit_location_for_pat(
+        &mut self,
+        pat_id: ra_ap_hir_def::hir::PatId,
+        source_map: &BodySourceMap,
+    ) -> Option<trap::Label> {
+        let source = source_map.pat_syntax(pat_id).ok()?;
+        self.emit_location_for_ast_ptr(source)
+    }
+
+    fn emit_literal_or_const_pat(
+        &mut self,
+        pat: &ra_ap_hir_def::hir::LiteralOrConst,
+        location: Option<trap::Label>,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        match pat {
+            ra_ap_hir_def::hir::LiteralOrConst::Literal(_literal) => {
+                let expr = self.trap.emit(generated::LiteralExpr {
+                    id: TrapId::Star,
+                    location: None,
+                });
+                self.trap.emit(generated::LitPat {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::LiteralOrConst::Const(inner) => {
+                self.emit_pat(*inner, body, source_map)
+            }
+        }
+    }
+
+    fn emit_location_for_label(
+        &mut self,
+        label_id: ra_ap_hir_def::hir::LabelId,
+        source_map: &BodySourceMap,
+    ) -> Option<trap::Label> {
+        // 'catch' a panic if the source map is incomplete
+        let source = std::panic::catch_unwind(|| source_map.label_syntax(label_id)).ok();
+        source.and_then(|source| self.emit_location_for_ast_ptr(source))
+    }
     fn emit_location<T: HasSource>(&mut self, entity: T) -> Option<trap::Label>
     where
         T::Ast: AstNode,
@@ -74,11 +155,769 @@ impl CrateTranslator<'_> {
             .and_then(|(file_id, source)| self.emit_file(file_id).map(|data| (data, source)))
             .map(|(data, source)| {
                 let range = source.value.syntax().text_range();
-                let start = data.line_index.line_col(range.start());
-                let end = data.line_index.line_col(range.end());
-                self.trap.emit_location(data.label, start, end)
+                self.emit_location_for_textrange(data, range)
             })
     }
+    fn emit_location_for_textrange(&mut self, data: FileData, range: TextRange) -> trap::Label {
+        let start = data.line_index.line_col(range.start());
+        let end = data.line_index.line_col(
+            range
+                .end()
+                .checked_sub(TextSize::new(1))
+                .unwrap_or(range.end()),
+        );
+        self.trap.emit_location(data.label, start, end)
+    }
+    fn emit_label(
+        &mut self,
+        label_id: LabelId,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        let location: Option<trap::Label> = self.emit_location_for_label(label_id, source_map);
+        let label = &body.labels[label_id];
+        self.trap.emit(generated::Label {
+            id: TrapId::Star,
+            location,
+            name: label.name.as_str().into(),
+        })
+    }
+
+    fn emit_unimplemented(&mut self, location: Option<trap::Label>) -> trap::Label {
+        self.trap.emit(generated::Unimplemented {
+            id: TrapId::Star,
+            location,
+        })
+    }
+    fn emit_path(&mut self, _path: &Path, location: Option<trap::Label>) -> trap::Label {
+        self.emit_unimplemented(location)
+    }
+
+    fn emit_record_field_pat(
+        &mut self,
+        field_pat: &RecordFieldPat,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        let RecordFieldPat { name, pat } = field_pat;
+        let location = self.emit_location_for_pat(*pat, source_map);
+        let pat = self.emit_pat(*pat, body, source_map);
+        self.trap.emit(generated::RecordFieldPat {
+            id: TrapId::Star,
+            location,
+            name: name.as_str().into(),
+            pat,
+        })
+    }
+
+    fn emit_record_lit_field(
+        &mut self,
+        field_expr: &RecordLitField,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        let RecordLitField { name, expr } = field_expr;
+        let location = self.emit_location_for_expr(*expr, source_map);
+        let expr = self.emit_expr(*expr, body, source_map);
+        self.trap.emit(generated::RecordLitField {
+            id: TrapId::Star,
+            location,
+            name: name.as_str().into(),
+            expr,
+        })
+    }
+    fn emit_pat(&mut self, pat_id: PatId, body: &Body, source_map: &BodySourceMap) -> trap::Label {
+        let location: Option<trap::Label> = self.emit_location_for_pat(pat_id, source_map);
+        let pat = &body.pats[pat_id];
+        match pat {
+            ra_ap_hir_def::hir::Pat::Missing => self.trap.emit(generated::MissingPat {
+                id: TrapId::Star,
+                location,
+            }),
+            ra_ap_hir_def::hir::Pat::Wild => self.trap.emit(generated::WildPat {
+                id: TrapId::Star,
+                location,
+            }),
+            ra_ap_hir_def::hir::Pat::Tuple { args, ellipsis } => {
+                let args = args
+                    .into_iter()
+                    .map(|pat| self.emit_pat(*pat, body, source_map))
+                    .collect();
+                let ellipsis_index = ellipsis.and_then(|x| x.try_into().ok());
+                self.trap.emit(generated::TuplePat {
+                    id: TrapId::Star,
+                    location,
+                    args,
+                    ellipsis_index,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Or(args) => {
+                let args = args
+                    .into_iter()
+                    .map(|pat| self.emit_pat(*pat, body, source_map))
+                    .collect();
+                self.trap.emit(generated::OrPat {
+                    id: TrapId::Star,
+                    location,
+                    args,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Record {
+                path,
+                args,
+                ellipsis,
+            } => {
+                let path = path.as_ref().map(|path| self.emit_path(path, location));
+                let args = args
+                    .into_iter()
+                    .map(|arg| self.emit_record_field_pat(arg, body, source_map))
+                    .collect();
+                self.trap.emit(generated::RecordPat {
+                    id: TrapId::Star,
+                    location,
+                    path,
+                    args,
+                    has_ellipsis: *ellipsis,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Range { start, end } => {
+                let start = start
+                    .as_ref()
+                    .map(|x| self.emit_literal_or_const_pat(x, location, body, source_map));
+                let end = end
+                    .as_ref()
+                    .map(|x| self.emit_literal_or_const_pat(x, location, body, source_map));
+                self.trap.emit(generated::RangePat {
+                    id: TrapId::Star,
+                    location,
+                    start,
+                    end,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Slice {
+                prefix,
+                slice,
+                suffix,
+            } => {
+                let prefix = prefix
+                    .into_iter()
+                    .map(|pat| self.emit_pat(*pat, body, source_map))
+                    .collect();
+                let slice = slice.map(|pat| self.emit_pat(pat, body, source_map));
+                let suffix = suffix
+                    .into_iter()
+                    .map(|pat| self.emit_pat(*pat, body, source_map))
+                    .collect();
+                self.trap.emit(generated::SlicePat {
+                    id: TrapId::Star,
+                    location,
+                    prefix,
+                    slice,
+                    suffix,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Path(path) => {
+                let path = self.emit_path(path, location);
+                self.trap.emit(generated::PathPat {
+                    id: TrapId::Star,
+                    location,
+                    path,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Lit(expr) => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::LitPat {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Bind { id, subpat } => {
+                let subpat = subpat.map(|pat| self.emit_pat(pat, body, source_map));
+                self.trap.emit(generated::BindPat {
+                    id: TrapId::Star,
+                    location,
+                    subpat,
+                    binding_id: body.bindings[*id].name.as_str().into(),
+                })
+            }
+            ra_ap_hir_def::hir::Pat::TupleStruct {
+                path,
+                args,
+                ellipsis,
+            } => {
+                let path = path.as_ref().map(|path| self.emit_path(path, location));
+                let args = args
+                    .into_iter()
+                    .map(|arg| self.emit_pat(*arg, body, source_map))
+                    .collect();
+                self.trap.emit(generated::TupleStructPat {
+                    id: TrapId::Star,
+                    location,
+                    path,
+                    args,
+                    ellipsis_index: ellipsis.map(|x| x as usize),
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Ref { pat, mutability } => {
+                let pat = self.emit_pat(*pat, body, source_map);
+                self.trap.emit(generated::RefPat {
+                    id: TrapId::Star,
+                    location,
+                    pat,
+                    is_mut: mutability.is_mut(),
+                })
+            }
+            ra_ap_hir_def::hir::Pat::Box { inner } => {
+                let inner = self.emit_pat(*inner, body, source_map);
+                self.trap.emit(generated::BoxPat {
+                    id: TrapId::Star,
+                    location,
+                    inner,
+                })
+            }
+            ra_ap_hir_def::hir::Pat::ConstBlock(expr) => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::ConstBlockPat {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+        }
+    }
+    fn emit_type_ref(&mut self, _type_ref: &TypeRef) -> trap::Label {
+        self.emit_unimplemented(None)
+    }
+    fn emit_match_arm(
+        &mut self,
+        arm: &MatchArm,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        let location: Option<trap::Label> = self.emit_location_for_pat(arm.pat, source_map);
+        let pat = self.emit_pat(arm.pat, body, source_map);
+        let guard = arm.guard.map(|g| self.emit_expr(g, body, source_map));
+        let expr = self.emit_expr(arm.expr, body, source_map);
+        self.trap.emit(generated::MatchArm {
+            id: TrapId::Star,
+            location,
+            pat,
+            guard,
+            expr,
+        })
+    }
+    fn emit_stmt(
+        &mut self,
+        stmt: &Statement,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        match stmt {
+            Statement::Let {
+                pat,
+                type_ref,
+                initializer,
+                else_branch,
+            } => {
+                // TODO: find a way to get the location of the entire statement
+                let location = self.emit_location_for_pat(*pat, source_map);
+                let pat = self.emit_pat(*pat, body, source_map);
+                let type_ref = type_ref
+                    .as_ref()
+                    .map(|type_ref| self.emit_type_ref(type_ref));
+                let initializer =
+                    initializer.map(|initializer| self.emit_expr(initializer, body, source_map));
+                let else_ = else_branch.map(|else_| self.emit_expr(else_, body, source_map));
+
+                self.trap.emit(generated::LetStmt {
+                    id: TrapId::Star,
+                    location,
+                    pat,
+                    type_ref,
+                    initializer,
+                    else_,
+                })
+            }
+            Statement::Expr { expr, has_semi } => {
+                let location = self.emit_location_for_expr(*expr, source_map);
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::ExprStmt {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    has_semicolon: *has_semi,
+                })
+            }
+            Statement::Item => self.trap.emit(generated::ItemStmt {
+                id: TrapId::Star,
+                location: None,
+            }),
+        }
+    }
+    fn emit_expr(
+        &mut self,
+        expr_id: ExprId,
+        body: &Body,
+        source_map: &BodySourceMap,
+    ) -> trap::Label {
+        let location: Option<trap::Label> = self.emit_location_for_expr(expr_id, source_map);
+        let expr = &body[expr_id];
+        match expr {
+            ra_ap_hir_def::hir::Expr::Missing => self.trap.emit(generated::MissingExpr {
+                id: TrapId::Star,
+                location,
+            }),
+            ra_ap_hir_def::hir::Expr::Path(path) => {
+                let path = self.emit_path(path, location);
+                self.trap.emit(generated::PathExpr {
+                    id: TrapId::Star,
+                    location,
+                    path,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::If {
+                condition,
+                then_branch,
+                else_branch,
+            } => {
+                let condition = self.emit_expr(*condition, body, source_map);
+                let then = self.emit_expr(*then_branch, body, source_map);
+                let else_ = else_branch.map(|x| self.emit_expr(x, body, source_map));
+                self.trap.emit(generated::IfExpr {
+                    id: TrapId::Star,
+                    location,
+                    condition,
+                    then,
+                    else_,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Let { pat, expr } => {
+                let pat = self.emit_pat(*pat, body, source_map);
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::LetExpr {
+                    id: TrapId::Star,
+                    location,
+                    pat,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Block {
+                id: _,
+                statements,
+                tail,
+                label,
+            } => {
+                let statements = statements
+                    .into_iter()
+                    .map(|stmt| self.emit_stmt(stmt, body, source_map))
+                    .collect();
+                let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
+                let label = label.map(|l| self.emit_label(l, body, source_map));
+                self.trap.emit(generated::BlockExpr {
+                    id: TrapId::Star,
+                    location,
+                    statements,
+                    tail,
+                    label,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Async {
+                id: _,
+                statements,
+                tail,
+            } => {
+                let statements = statements
+                    .into_iter()
+                    .map(|stmt| self.emit_stmt(stmt, body, source_map))
+                    .collect();
+                let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
+                self.trap.emit(generated::AsyncBlockExpr {
+                    id: TrapId::Star,
+                    location,
+                    statements,
+                    tail,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Const(const_block) => {
+                let expr_id = self.db.lookup_intern_anonymous_const(*const_block).root;
+                let expr = self.emit_expr(expr_id, body, source_map);
+                self.trap.emit(generated::ConstExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Unsafe {
+                id: _,
+                statements,
+                tail,
+            } => {
+                let statements = statements
+                    .into_iter()
+                    .map(|stmt| self.emit_stmt(stmt, body, source_map))
+                    .collect();
+                let tail = tail.map(|expr_id| self.emit_expr(expr_id, body, source_map));
+                self.trap.emit(generated::UnsafeBlockExpr {
+                    id: TrapId::Star,
+                    location,
+                    statements,
+                    tail,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Loop {
+                body: loop_body,
+                label,
+            } => {
+                let loop_body = self.emit_expr(*loop_body, body, source_map);
+                let label = label.map(|l| self.emit_label(l, body, source_map));
+                self.trap.emit(generated::LoopExpr {
+                    id: TrapId::Star,
+                    location,
+                    body: loop_body,
+                    label,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Call {
+                callee,
+                args,
+                is_assignee_expr,
+            } => {
+                let callee = self.emit_expr(*callee, body, source_map);
+                let args = args
+                    .into_iter()
+                    .map(|e| self.emit_expr(*e, body, source_map))
+                    .collect();
+                self.trap.emit(generated::CallExpr {
+                    id: TrapId::Star,
+                    location,
+                    callee,
+                    args,
+                    is_assignee_expr: *is_assignee_expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::MethodCall {
+                receiver,
+                method_name,
+                args,
+                generic_args,
+            } => {
+                let receiver = self.emit_expr(*receiver, body, source_map);
+                let args = args
+                    .into_iter()
+                    .map(|e| self.emit_expr(*e, body, source_map))
+                    .collect();
+                let generic_args = generic_args
+                    .as_ref()
+                    .map(|_args| self.emit_unimplemented(None));
+                self.trap.emit(generated::MethodCallExpr {
+                    id: TrapId::Star,
+                    location,
+                    receiver,
+                    method_name: method_name.as_str().into(),
+                    args,
+                    generic_args,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Match { expr, arms } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                let branches = arms
+                    .into_iter()
+                    .map(|e| self.emit_match_arm(e, body, source_map))
+                    .collect();
+
+                self.trap.emit(generated::MatchExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    branches,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Continue { label } => {
+                let label = label.map(|l| self.emit_label(l, body, source_map));
+                self.trap.emit(generated::ContinueExpr {
+                    id: TrapId::Star,
+                    location,
+                    label,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Break { expr, label } => {
+                let expr = expr.map(|e| self.emit_expr(e, body, source_map));
+                let label = label.map(|l| self.emit_label(l, body, source_map));
+                self.trap.emit(generated::BreakExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    label,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Return { expr } => {
+                let expr = expr.map(|e| self.emit_expr(e, body, source_map));
+                self.trap.emit(generated::ReturnExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Become { expr } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::BecomeExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Yield { expr } => {
+                let expr = expr.map(|e| self.emit_expr(e, body, source_map));
+                self.trap.emit(generated::YieldExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Yeet { expr } => {
+                let expr = expr.map(|e| self.emit_expr(e, body, source_map));
+                self.trap.emit(generated::YeetExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::RecordLit {
+                path, //TODO
+                fields,
+                spread,
+                ellipsis,
+                is_assignee_expr,
+            } => {
+                let path = path.as_ref().map(|path| self.emit_path(path, location));
+                let fields = fields
+                    .into_iter()
+                    .map(|field| self.emit_record_lit_field(field, body, source_map))
+                    .collect();
+                let spread = spread.map(|expr_id| self.emit_expr(expr_id, body, source_map));
+                self.trap.emit(generated::RecordLitExpr {
+                    id: TrapId::Star,
+                    location,
+                    path,
+                    fields,
+                    spread,
+                    has_ellipsis: *ellipsis,
+                    is_assignee_expr: *is_assignee_expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Field { expr, name } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::FieldExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    name: name.as_str().into(),
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Await { expr } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::AwaitExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Cast { expr, type_ref } => {
+                let expr: trap::Label = self.emit_expr(*expr, body, source_map);
+                let type_ref: trap::Label = self.emit_type_ref(type_ref.as_ref());
+                self.trap.emit(generated::CastExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    type_ref,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Ref {
+                expr,
+                rawness,
+                mutability,
+            } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::RefExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    is_mut: mutability.is_mut(),
+                    is_raw: rawness.is_raw(),
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Box { expr } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                self.trap.emit(generated::BoxExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::UnaryOp { expr, op } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                let op = match op {
+                    ra_ap_syntax::ast::UnaryOp::Deref => "*",
+                    ra_ap_syntax::ast::UnaryOp::Not => "!",
+                    ra_ap_syntax::ast::UnaryOp::Neg => "-",
+                };
+                self.trap.emit(generated::UnaryOpExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                    op: op.into(),
+                })
+            }
+            ra_ap_hir_def::hir::Expr::BinaryOp { lhs, rhs, op } => {
+                let lhs = self.emit_expr(*lhs, body, source_map);
+                let rhs = self.emit_expr(*rhs, body, source_map);
+                let op = op.map(|op| format!("{op}"));
+                self.trap.emit(generated::BinaryOpExpr {
+                    id: TrapId::Star,
+                    location,
+                    lhs,
+                    rhs,
+                    op,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Range {
+                lhs,
+                rhs,
+                range_type,
+            } => {
+                let lhs = lhs.map(|lhs| self.emit_expr(lhs, body, source_map));
+                let rhs = rhs.map(|rhs| self.emit_expr(rhs, body, source_map));
+                self.trap.emit(generated::RangeExpr {
+                    id: TrapId::Star,
+                    location,
+                    lhs,
+                    rhs,
+                    is_inclusive: *range_type == RangeOp::Inclusive,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Index {
+                base,
+                index,
+                is_assignee_expr,
+            } => {
+                let base = self.emit_expr(*base, body, source_map);
+                let index = self.emit_expr(*index, body, source_map);
+                self.trap.emit(generated::IndexExpr {
+                    id: TrapId::Star,
+                    location,
+                    base,
+                    index,
+                    is_assignee_expr: *is_assignee_expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Closure {
+                args,
+                arg_types,
+                ret_type,
+                body: expr,
+                closure_kind, //TODO:
+                capture_by,
+            } => {
+                let expr = self.emit_expr(*expr, body, source_map);
+                let args = args
+                    .into_iter()
+                    .map(|arg| self.emit_pat(*arg, body, source_map))
+                    .collect();
+                let ret_type = ret_type
+                    .as_ref()
+                    .map(|ret_type| self.emit_type_ref(ret_type));
+                let arg_types = arg_types
+                    .into_iter()
+                    .map(|arg_type| {
+                        arg_type
+                            .as_ref()
+                            .map(|arg_type| self.emit_type_ref(arg_type))
+                    })
+                    .collect();
+                self.trap.emit(generated::ClosureExpr {
+                    id: TrapId::Star,
+                    location,
+                    args,
+                    arg_types,
+                    body: expr,
+                    ret_type,
+                    closure_kind: format!("{:?}", closure_kind),
+                    is_move: *capture_by == CaptureBy::Value,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Tuple {
+                exprs,
+                is_assignee_expr,
+            } => {
+                let exprs = exprs
+                    .into_iter()
+                    .map(|expr| self.emit_expr(*expr, body, source_map))
+                    .collect();
+                self.trap.emit(generated::TupleExpr {
+                    id: TrapId::Star,
+                    location,
+                    exprs,
+                    is_assignee_expr: *is_assignee_expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::ElementList {
+                elements,
+                is_assignee_expr,
+            }) => {
+                let elements = elements
+                    .into_iter()
+                    .map(|expr| self.emit_expr(*expr, body, source_map))
+                    .collect();
+                self.trap.emit(generated::ElementListExpr {
+                    id: TrapId::Star,
+                    location,
+                    elements,
+                    is_assignee_expr: *is_assignee_expr,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Array(ra_ap_hir_def::hir::Array::Repeat {
+                initializer,
+                repeat,
+            }) => {
+                let initializer: trap::Label = self.emit_expr(*initializer, body, source_map);
+                let repeat: trap::Label = self.emit_expr(*repeat, body, source_map);
+
+                self.trap.emit(generated::RepeatExpr {
+                    id: TrapId::Star,
+                    location,
+                    initializer,
+                    repeat,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::Literal(_literal) => self.trap.emit(generated::LiteralExpr {
+                id: TrapId::Star,
+                location,
+            }),
+            ra_ap_hir_def::hir::Expr::Underscore => self.trap.emit(generated::UnderscoreExpr {
+                id: TrapId::Star,
+                location,
+            }),
+            ra_ap_hir_def::hir::Expr::OffsetOf(offset) => {
+                let container = self.emit_type_ref(&offset.container);
+                let fields = offset.fields.iter().map(|x| x.as_str().into()).collect();
+                self.trap.emit(generated::OffsetOfExpr {
+                    id: TrapId::Star,
+                    location,
+                    container,
+                    fields,
+                })
+            }
+            ra_ap_hir_def::hir::Expr::InlineAsm(asm) => {
+                let expr = self.emit_expr(asm.e, body, source_map);
+                self.trap.emit(generated::InlineAsmExpr {
+                    id: TrapId::Star,
+                    location,
+                    expr,
+                })
+            }
+        }
+    }
 
     fn emit_definition(
         &mut self,
@@ -87,30 +926,68 @@ impl CrateTranslator<'_> {
         labels: &mut Vec<trap::Label>,
     ) {
         match id {
-            ModuleDef::Module(_) => {}
+            ModuleDef::Module(_) => {
+                self.emit_unimplemented(None);
+            }
             ModuleDef::Function(function) => {
+                let def: ra_ap_hir::DefWithBody = function.into();
+
                 let name = function.name(self.db);
                 let location = self.emit_location(function);
-                let body = self.trap.emit(generated::MissingExpr {
-                    id: TrapId::Star,
-                    location: None,
-                });
+
+                let body = if self.extract_dependencies || self.krate.origin(self.db).is_local() {
+                    let (body, source_map) = self.db.body_with_source_map(def.into());
+                    let txt = body.pretty_print(self.db, def.into(), Edition::Edition2021);
+                    log::trace!("{}", &txt);
+                    self.emit_expr(body.body_expr, &body, &source_map)
+                } else {
+                    self.trap.emit(generated::MissingExpr {
+                        id: TrapId::Star,
+                        location: None,
+                    })
+                };
                 labels.push(self.trap.emit(generated::Function {
                     id: trap_key![module_label, name.as_str()],
                     location,
                     name: name.as_str().into(),
                     body,
-                }));
+                }))
+            }
+            ModuleDef::Adt(adt) => {
+                let location = self.emit_location(adt);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::Variant(variant) => {
+                let location = self.emit_location(variant);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::Const(const_) => {
+                let location = self.emit_location(const_);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::Static(static_) => {
+                let location = self.emit_location(static_);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::Trait(trait_) => {
+                let location = self.emit_location(trait_);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::TraitAlias(alias) => {
+                let location = self.emit_location(alias);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::TypeAlias(type_alias) => {
+                let location = self.emit_location(type_alias);
+                self.emit_unimplemented(location);
+            }
+            ModuleDef::BuiltinType(_builtin_type) => {
+                self.emit_unimplemented(None);
+            }
+            ModuleDef::Macro(macro_) => {
+                let location = self.emit_location(macro_);
+                self.emit_unimplemented(location);
             }
-            ModuleDef::Adt(_) => {}
-            ModuleDef::Variant(_) => {}
-            ModuleDef::Const(_) => {}
-            ModuleDef::Static(_) => {}
-            ModuleDef::Trait(_) => {}
-            ModuleDef::TraitAlias(_) => {}
-            ModuleDef::TypeAlias(_) => {}
-            ModuleDef::BuiltinType(_) => {}
-            ModuleDef::Macro(_) => {}
         }
     }
 

rust/extractor/src/trap.rs

@@ -85,10 +85,10 @@ impl TrapFile {
         start: LineCol,
         end: LineCol,
     ) -> trap::Label {
-        let start_line = start.line as usize;
-        let start_column = start.col as usize;
-        let end_line = end.line as usize;
-        let end_column = end.col as usize;
+        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,

rust/ql/.generated.list

@@ -1,212 +1,223 @@
-lib/codeql/rust/elements/Array.qll c33de8fd2c0acbf221441dd67b061d3ab169f0bf548c0c957884455a215fce5c c54c716551746afd895da187e3d03acbe481bdf1ca4461065555641480801c2d
+lib/codeql/rust/elements/ArrayExpr.qll aa558ac94bb7c45145e4788ed1a92e2873c5f57f1a0c7b7faf341f40027cf455 874da62a3d6467af7ae11045229135f8f5229cff33f3edae5b01a5b9afe86dd7
 lib/codeql/rust/elements/AstNode.qll 2069047c779514867c12d845dcdf889db6f27fa6a9e484966a3c28a77973b7d4 e214616c81418b0018c0d36896ac2ec7273634e3213bc8257d8b172f396c00ee
-lib/codeql/rust/elements/AsyncBlock.qll ac5899827719dae561540d1c460540bd3242b79ee98f0ea3f9391e98f7a6b680 a0d64b5896fcc2c8292b757645a0041c716ac0e9b85264729898347361061c8b
-lib/codeql/rust/elements/AsyncBlockConstructor.qll c094b929e6f3e7053973e80b26b13989e90d603da0cc073679c9e6594c3eceba 95e55c95007e392ebcc43a895bf26ff5983598f7ffb1e3fdee2858ce61b50ea0
-lib/codeql/rust/elements/Await.qll b143784cf3a536d67bcddc6145fca944e34b5262975d1f13fc8922dda8cac39d bf8b3b173708b0dfcab5c84407e17d488ac1e94e285f6ee8723a71cae81eeea3
-lib/codeql/rust/elements/AwaitConstructor.qll b34c0592c512ab38f7a7106b3416ba53dad650a801e1a3adb4afc1dadf56ed1e dfbf6ff965abe7791898e7fb026c997a22ac7af23fa84ab87b4f9f74b89c2a70
-lib/codeql/rust/elements/Become.qll 57a2a0a42f03ff8ebf29e3829762bf49cdbd01666a51ff83437124b281ecb31b a4ff816fb6d93151ab9cd6ec51739c1f869bb740d87b522dca1917f13fab1978
-lib/codeql/rust/elements/BecomeConstructor.qll 783ec64a9d8921d3613208eb4ad15acd9a227d1182e099d3aa15dd7a25030443 48e35b3c39532468101141af0ef324ad1d09cc263de8fa9e28d08e0e8d6d72c3
-lib/codeql/rust/elements/BinaryOp.qll 5688f95eb9d6615e04fdb16654e5756ba0a250790d322247d59aaf2df7058d1c 66e403bfbfc4ad70be0a702e70d742daff1d98697711fdd19a2c54f9e2969ebc
-lib/codeql/rust/elements/BinaryOpConstructor.qll 4e9b81d972c3ce4cd38baa0bbb5a1bb5a4a6d135e189df43e041926ccf770efe 1ae5b9f5b8f9f31bfe4b4b2fc437f1673d721f4a278f3d7490497e59a6f99c3a
+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/Block.qll 03adb9118a899bfdd3790d82426eb6ee3df83d03d6e0eceb5d05bc9b8f08c576 c65f594a7d576889ddb13b3ec16175e1ceb09e9f289a23e91708be6d728573bb
-lib/codeql/rust/elements/BlockBase.qll 3ce5ef025d1fb293a6708e74a78761590a6ed3fdeabb70795f18170598d45566 6aeac52ec999f2b2e8f96c425a44c4eb3a3efb77bbcf76e9c496137c5773769b
-lib/codeql/rust/elements/BlockConstructor.qll 07cd9123ae847a04b84fd410eee835fbf1088e88d1f1bfcf3e2a66ee5ac3ca8c 15d9e5be5a43c70aea9a280e114889f277fc3c2d83638d9e5cb7dbfb559c56c4
-lib/codeql/rust/elements/Box.qll 8fa74f14d72cb8613e9ddc4effc19054cb745c91582aa7a440d68f02b9c13b9c 1e196173be41e5059fc538c1cda01ccfea644425030584e2689c68abf7850935
-lib/codeql/rust/elements/BoxConstructor.qll 9a76f8b87367812ac7be252d04802f09a97659869098391bcdd46e6da72840cc 8225e3743257dd1a927a7c6eabdfd082011e1124ffeb10e4020b52c41556fa12
+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/Break.qll 39ddf63748d5df0fe2f36e88ed656007d8adcb94110ef513d5b6148e96b532ba f7a90bcf424db38bfbee9300e418a4a2e304822d882d1221da90e719bcf4d092
-lib/codeql/rust/elements/BreakConstructor.qll 6642b7b9624dda02bfc9178d0f40cf8937d1cc1629621c526a0be50525ba5cc1 473d11dd648c355fbcc9603eae65501513be7f84e92bc06ae415c393b3d5b55e
-lib/codeql/rust/elements/Call.qll be1c6c66ec2076b7c11cd57caddca591ecea321b0053287182b7951c051646f3 fc2b36ee527f31e1fa00d92a5941a6f86f336356fce168b23ba6b3bb9e52fb1c
-lib/codeql/rust/elements/CallConstructor.qll d5a805a645829fa261619909bc80804a188f5e043dbc40a498fae7e3fac9891a 4e14e345ff5f253d09de6142c886a97420b37b12f7d92afcd011150b914322ba
-lib/codeql/rust/elements/Cast.qll 02093710cebd4ace265e1f1b84287be8bf15ea6390acf4e3c08a9727ef8d76bb 9c870b6e7ec202437041d374262377055db72d8fa3610cb4d39122f673e0ff3c
-lib/codeql/rust/elements/CastConstructor.qll f94723d4cc9197d10b706b6945ed2869b5f73d5b7e0d8487151624eb2a3ac345 2cc4f0dc93dce5a811bab3708d97686668bc04966490617e394277411bfc647f
-lib/codeql/rust/elements/Closure.qll 3ebb4e36aeced34c77370b103ec0a5748bebc85c70a706a1b46cf625e5e5de25 83d40cfff2569fc691d82daab08ff9fe1aa6b03ef3e3c38f0f61c11a2e531d9c
-lib/codeql/rust/elements/ClosureConstructor.qll d489970d2ab853e20cc50b0a2a68e36be2c376dfe37ae1099b0c4eb59d841107 2e0788d23c3c7a94d23bb568874bd8b99e8ac6bc5d294e4c2fec0cc54bb97229
-lib/codeql/rust/elements/Const.qll 117efce95fd61f3845e6e378bb46246f3ead808031f435847f0c121aec236172 d6a626696985847950e8f904cf842b971b00ce2f4108f4b54716503825c292b8
+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/ConstConstructor.qll aa9cc5e0131c6c4ca0022d5cfc20783a0bd3a3e43d46f58b9951c2b22eaa071c 3af96dbdf939f0b170f7f46f71cf0ede2944e638a611c86b660630c86eaba29a
-lib/codeql/rust/elements/Continue.qll c4148199252ae1d13c572063d8f73d77d798b1cf3fcab16924e154e7a09aeb49 13f81945ea35613c910e933da800c6e80c3a75859092df185910483b8a5bfc1f
-lib/codeql/rust/elements/ContinueConstructor.qll 541a6ae2c3c2d4552e16368f6b94f6e74c58933c139fc775e2b123270bb63a1b dc99f93f41bf53a0d025a025bbf917b1fc3aae8908f9d2f9e243103b478e33fb
+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/ElementList.qll e969e89e4375363dc17a779e3b963d63528d72d38ef70810088a2d53c4999cc6 b10f5dda8aa1af683e58c3c86c4d2117f60582a3de2a2f0903b905d333798b47
-lib/codeql/rust/elements/ElementListConstructor.qll b21ada740a8a53b3abc63b7b338b55054f03d72e7a3581f9ac11e1c9b99e569e 40cda192387dfe882557b224ee28647330d8471d596b76debc549ebe2d4cf6a2
+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/Field.qll 598169fd695762b54dc71fe56400fd19e62f314a824f7f9cae3441f77c698f58 0da139a7acb789881022f55a59e0368818f9100dbf50dd38c5489d587e0fcdac
-lib/codeql/rust/elements/FieldConstructor.qll 3bf050aba1d6b17529500aa93e051139380fa918c175044ae39143db29929836 b589557f39a524e8565292453c50946d7f491b10f4e7ca5c187ee7829e73d595
+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/If.qll 7fcb0fdded3431c2adcb5daa6b61c95ee8a4da563d73603b6f396a36d09e7fab e2507dd776ca911dadd792268e79a68ad7aac7203fabc28eac29ad6d8b864ea8
-lib/codeql/rust/elements/IfConstructor.qll 31f1965a186b7c0e55bce6dc060b07fd9e67a7e1dece7444825ccad5c27940a0 8a542b21713f24a6de13e2513b89a6f442a83dbb04226d4ee2b9214159a8f94c
-lib/codeql/rust/elements/IfLet.qll 83a1d686ea6b99af775814ecad169ce0cded40d159ca4c3ad917e79607a6234f dd47bd70aa801f9a2cea84379a52c09e15f678c43abe33a2b6cbef3dd7eda43c
-lib/codeql/rust/elements/IfLetConstructor.qll cf99514825c25eca2126e3f855d06ef588cef93d6f131586e44083325477f1d7 c4e4082549bfd1885496f4d67a2d54012dd84b2a5a1461d76e8b025097cdd064
-lib/codeql/rust/elements/Index.qll 0a2ec6ed6616eb3f9f85a2d63184ead503f20c8050e623079c5a1dc94f035300 4e91229765fedd5a66ba2e0968f7f1ffde36c7039d51d729a740cd304a52cfe1
-lib/codeql/rust/elements/IndexConstructor.qll 518349246cb64d07f45a9be11061e6cba9da674a7406334d10422e992e02f928 a89aef36d63d09aa08074c4fc79ef046359f955faefd9b0141cdc60008b5ad71
-lib/codeql/rust/elements/InlineAsm.qll 3ff6a13840a083ac39672aa694213b3740bc2c8654d489813c97c28abad8e991 6270b298f10ed3f9427cd7c0119e44f5441c7589322821578a6b236147929805
-lib/codeql/rust/elements/InlineAsmConstructor.qll 3923d1b0d772e0686ce891e63c39b984fabbc9c2656f9177df1696e85eff12bf 3ce886c37495ee40eb9d12c2b4ee0222b34f3d9df5a23a47ea2e629c54c30a58
+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/Let.qll 2148dd54c4f109f1668b724d547ee4e4fe86820fa554a57f2806da102ec8d5cf 7a44c96aadba848b36d26325499d2011e3a1f2f3ee26f78b9202fc39130a6a57
-lib/codeql/rust/elements/LetConstructor.qll c696cefd2d2c8e2a56e5df6e63cd5302833bf5bc1d16ff87666cd8a8b01eb7f0 8065946e2b996abbd58fef9f03ae30c98369367153acd8681a87422d07b36a68
+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/Literal.qll 25eca7baf71894a8826493ee433897de3d47a82e897317239ae11ab1e850518d 413a56eed1703c4a07d900d9c7006e6770c6fe31b81711ddc00c0bd333f11d7c
-lib/codeql/rust/elements/LiteralConstructor.qll 6a80cc2175b6f7ceeedab2c06ca7f980ccbf64f6a7dda8c779fc92cecf91f7bc 177eee9c8214f2a776df18fc02754a6685f116aefe00d1444643eea954436739
-lib/codeql/rust/elements/Loop.qll a5e490726c68cb8e5bee0a90891ed8e2018d8ff80dad7ff59233f7a425afea3a 8dddc6c579de9ed7932296b6aec6253764eff1c7155778abb9b74b6d591769df
-lib/codeql/rust/elements/LoopConstructor.qll feae830d063f25fab417bf9b2981406d5427a090552aaffe7f166a2e7eec4ce1 860a66865a473df5848d9591fcf0ebeab5a5a87653d27cde97e4f10ae004e3b7
-lib/codeql/rust/elements/Match.qll c8eaabc6c02c3fd50c05d5067c10641c0fcdf8f838c98ada2b5a851c7da8bc6e d47cfc0ebd04474b59d0e918656662d6501cb928ff9af96621edae7f4ffef392
+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/MatchConstructor.qll 9d0fbd176257148010ca79fd496b0bf489838e02cdfddb30ee9156b573088f7a 3995df463f80e02c9d66e4fef652e3902c603b3dc7a94d71ebc42176616cb6fb
-lib/codeql/rust/elements/MethodCall.qll 213704bb1dfa3872331fffc27cb4c63b6c78614acc5865cc1aaae45479662670 f8dca58ac0db62e7fc4dc582efe8edc6112688878d7f5831c6986d0747c92c97
-lib/codeql/rust/elements/MethodCallConstructor.qll 1a0db56c1c2503467a105e5727ad132b4ecc6b84ca9bdb457ef0dbfddac5b622 9c0b3e1fe997323b60d258f504b48228d62737c2f1aaed2b1a60c29a0f783fe8
+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/OffsetOf.qll b815be1155d34c3e74da871f275b78e5aadfb62ae6e3232529af3d0b30e385a9 d3a1709c7d0958ff8b90ce8327f5566228d6ff582f45c9f88daa0b47e937fab2
-lib/codeql/rust/elements/OffsetOfConstructor.qll aa4bac3adf272e9f5f4d0f8ad63df3364dd1ed84aa8efebb60604e45baa3b3f0 30fdb49660f5bb838a3309e50a75c196b59dbee315a958ac991f669111205c1d
+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/Path.qll 05a168a83168638e07eb3d746adad7ecd952976dfed6fd85becc0fd491bf4b0f 8f38d2ae227dfd4fc7cedde3008dc66df57aa4ac1714c8d5105c9989b4e8b93e
-lib/codeql/rust/elements/PathConstructor.qll 97243db75d6337cf68a22ea68569fdddf4c3bc1b8875bb4bb66faeeba8846a53 03c8c665e2f3b103148fd38eb7a4d0459c8189b2f6160dc08ee1d6d2807e01b6
+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/Range.qll e9f66460c8a11b594298c00998ffd17ea39126e07a71319469174487e22f59bf b0df73a26c5f8decc1d95245fdefd823ec4c0c7642b93f518e77ad5055502dd4
-lib/codeql/rust/elements/RangeConstructor.qll 4a0e4e782e6bfd1ef5377a27df6929b0d8cfb24d90a89cf8623f17cee74621fe a05eb96fdb5feff50be7c93575d32b15e62425bb347b0a8fbf1b8c18a535cb9a
+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/RecordLit.qll 9c68193cebe8f709837b999e40a3af713e774c271a5a9195ad1fcdd8dbef4326 8e64bdd98a40f5724c3f7e43cad3c7522257fffe1e8c78da2068509ffe6719ee
-lib/codeql/rust/elements/RecordLitConstructor.qll 56b607c8777acb65d8061a835f818628b415d5b0258e1b5e5948106f6d95555e 64c99fc35ff4f8d8c8c980c1d5eb4e58e20dc4648beda1ed6b1b4180ef5ae887
+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/Ref.qll ce21e04980cd53e453dbe79931418c8527102aab2e2bd3f26e1c7a15f355a0fc 8d5b16ee1ba8574035e75227b7d2b1799d9e19a77dba778845b174bb767ca40b
-lib/codeql/rust/elements/RefConstructor.qll bf669bb7392c120a8125913ee7ef3fe14436a753bff5e8697d4c336cfac0b491 0124097f1831f27b440293dd0fdb70b9d54a61f669b43bdd68e9e2937737dd02
+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/Repeat.qll 9210ab6a659b0e21cefc12903ae4d7f3a3d663d80807c1634a00fbb66803454a a0c0b2187c0b32530d13f047a686a70c09c8efd372fd1afddff1d296e41a2888
-lib/codeql/rust/elements/RepeatConstructor.qll 1066aaeb7340979cb35571ec58a80fc79984da5a90541a05e8342715facbdbd6 363c0f4371a1a6c8dd3f29b38e421b4b5062bf53b6ddbc5fc1faa534d25a8359
-lib/codeql/rust/elements/Return.qll 60237f2c90a93c0df852eba89a635f0014ce072ec2acb80137a1da07a12e4b16 cc914eecc5d0522e81a41a1901bdf6f4c7535888bc104d9ac30bde243d12210e
-lib/codeql/rust/elements/ReturnConstructor.qll cdbbe70dab2be11453f1e98251ee7100d1a043f2d38b141615d3cdd53e3b62cf 8f3227e0eba7b06a9a19195b548807d87ce901a2d09fcaf23c89e53edf9f21a1
+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/Tuple.qll d7bddb240c9fe992d7940ee3e6cab0e1acdb2711be4776b07076ec7b9ba80dec 077792054a9e5d499f01f53ae919b428ada5ceaf4791192d1031ede774f84a75
-lib/codeql/rust/elements/TupleConstructor.qll 93e9248e33e213275d0be9513b29311f2390c6b68ac5b726bcece115a396499a 4539aa935419b20dd1ecb0bf634f991a311eb972bce4d8397b7a35f645b20e81
+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/UnaryOp.qll d0a80dee319119a4fd6b655a10451c390f7e41e096cf79bb3757c120c28de679 1fc33adb745b50fb6472be969b8df073208d8d092b459e35a65a4e978e436145
-lib/codeql/rust/elements/UnaryOpConstructor.qll 63fac5b262777aaac01eb9a67a990db578faadfc248149822453f6ece0f1dff7 f37488ee4acfa19095ef16e73042d7f17e66b30d936c691d54ef3b2d39663432
-lib/codeql/rust/elements/Underscore.qll a988d966016984c82ca1a22b86be751d3ee3da117b9333126cebe969e6cdc74b 81da73806731d80bd723bfa1c3c6be6ef0a0a906f49d2a20c52363e5ba39fafe
-lib/codeql/rust/elements/UnderscoreConstructor.qll 044463d55ca7d4cc1193b79fdc3140e33f68a1e3973a3d9262da4c49879999ac e024c4b988d5441dd032bdb0b521fed1074542e3e402e2fadae10bc9cab40aac
-lib/codeql/rust/elements/UnsafeBlock.qll 5a91fb3e0d05fa1379c02cee502732c020c9f33698cfdbef7ea2456cba40d2af 52b15480e82de093de9dc5993635f1c7d0d5c8c8cca310da0f58dc90dab80547
-lib/codeql/rust/elements/UnsafeBlockConstructor.qll c8ce086a87323a5223a9c815ae645f03d87534d09b72354d32db82dd082afe75 4f3880ecaacf46c28c8672a911edaaa18712b6b3a16e3cc0c4cb53fedaff256d
+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/Yeet.qll 07f967352be486b7e2b787c292c16195a7084699cbdf23e2214574afc455261a 593cf9528a531ad140e69b3ea3a885a7a2780abe3ea0d8ec1ef0a9b36b0c013d
-lib/codeql/rust/elements/YeetConstructor.qll 835afa5ff4b4102335525c41d67380e59f272f95b4b7b0196e0475eae4b9f738 6c51946d661aea16d91010e0639b4ea8f3d161bd56a029e955dc7f7bca025c00
-lib/codeql/rust/elements/Yield.qll 9a484b5b5c2c32ef61395213c376ce4b1ef7f699f08330d08faf071ea8919af1 e45fe09b794a2a05a1c125d112dfb36d9c7d538ff1953440d6c580cd8c987f8a
-lib/codeql/rust/elements/YieldConstructor.qll 16f393593cf9cf126f048c6f36eba7ca45e78c44577c7bda51c9a66bac95487e f49c9c3d4d17f64f44111bea2bb197cf8b11a0aa88b53b9a527c6aab4733c4b5
-lib/codeql/rust/elements.qll 031c02392e2e40c7a336c9a09a6b77d29b4ecf2fa81f692b36b6efd8ee576e48 031c02392e2e40c7a336c9a09a6b77d29b4ecf2fa81f692b36b6efd8ee576e48
-lib/codeql/rust/generated/Array.qll f9b0821628e9a72487322425ab6b9d232db5f9b24cd76d04e02124da96150667 253ad10a94f3783986ff436d6123d346074f79f0c9046e024abaa626106bc7e3
+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/AsyncBlock.qll 8ba28deb0ad9d6a887df2033eca4e4a4789a24c09e5ca720d38474226c6dbb0c 8ba28deb0ad9d6a887df2033eca4e4a4789a24c09e5ca720d38474226c6dbb0c
-lib/codeql/rust/generated/Await.qll f5d65ee72d03205b95b9f507a4da5706f5c66d0da8b4a8a5d67bfae5643a4766 382ad8a5e1098ec697370cdf5453404128abd9d56a1e578e0255aa29d33fcf74
-lib/codeql/rust/generated/Become.qll 7cfe61271eb91293014ebf16cd1029454705f4b569bba8afeec7d683f378efaf 9a31140d67ae8e77762aa2bd09ab018c88fe464a1b2205035e957d889abfe42a
-lib/codeql/rust/generated/BinaryOp.qll ec80f6cb6a0a03496814a629ecc8736f77c46e22a6c26b4e11fe1e650eb91441 67cd9c875556034a7afe78857c2d50d9ae1af084bee87e0d0c691c8baaaae72f
+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/Block.qll 25ce7676fb0a0925f039cb35ba94283d7c4a2fb806652374a198b56796497111 8efecec53c2964e546ce7ed6328f89923c57d58d572d42b63423b99709b50077
-lib/codeql/rust/generated/BlockBase.qll f1984b819cb8d2257c7e6323041c32bc106153c1a3fba75f052a545b84e9f09f 7e2767cee8967b5b8a53c1ad1de578a11f46629422ff1b2cebe051fe53293a91
-lib/codeql/rust/generated/Box.qll c64ff6a3e495d5729e091d275f04573ca820df2df1f42773dd04b0da0bf1d3d1 6d0778ae8347530f9ed5be9b24206f02d9437dd5265fdb308dfefce70f5d8829
+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/Break.qll 36f28582b12840a529514fcf0aac84ceaa452eca4442b347dd7b199659833ec7 ff03dc895c3c2baca41b17d358863cf9bd9209dc306d95c22f03db0716f664c7
-lib/codeql/rust/generated/Call.qll b2dc0c89cc8ca855cf38b82b5bcbbf0fb5cce2b5dafbb3eb253accea89818908 13441bcc3f0f68595cea49c4af14165335e67ceb83d2546ab4c45a5d054c2923
-lib/codeql/rust/generated/Cast.qll bfd3e61c0a7458adbed7d63bd5351ebdfcb11d42769fc2d34bafa6523f6e94ba e46d9a648e23a5e15e5c02d5d9666d827ef4732b7ac6b2edfc00d56cc239c845
-lib/codeql/rust/generated/Closure.qll 903b34f075623f952ebdafc105dc2efefd1816feed8df3b735919be8a7a7a5c7 bbb9ffddcc01e28223d1630a5052661ff00dda25f9f226cf8991773cf1862f84
-lib/codeql/rust/generated/Const.qll a1c6725f1b7b2482dfd996d44ec695c63230c1c28ee00d9bf694dd3f01831323 a1c6725f1b7b2482dfd996d44ec695c63230c1c28ee00d9bf694dd3f01831323
+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/Continue.qll 2aa6a5c99a66a852ee15322f931eeaeb2020732267a33e44adbc5218a77aa994 faf0c36fb1773233dd3c8f43bfb84037a36ef96d0f5b97b01865faf4ff79891e
+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/ElementList.qll 483c8592ac946216cc2eb5562668d3120629c34dd039c3fab10224d0fd62ddbd df3154df35e89df76a1a77740118d5a41769364bf82b1f00377cd4a3968ff634
+lib/codeql/rust/generated/ElementListExpr.qll 3f7e9c1f7249f7283406d2e59b00af750b6dea93b284d7f25af66fe4b3345fea d340242d6072e274fbafd6ff2a5455bf53b3b77ed91539e91563d67cf2ed48f0
 lib/codeql/rust/generated/Expr.qll 32cdd43d17e8b2fb7c73ec723eba89704d1e853e29d304db5eea3979fcdd2e0b 0b8382b0659afa1bd1d13d0cd492d7fbdc0fd7a5162fa658ca2973bc15ee6534
-lib/codeql/rust/generated/ExprStmt.qll 1aba8c482a307f27612317b4d895ac59389e23ff905b6061931fced12ff7c3d1 c4e42a8863cfe4e83eddcd82236da2dbb1fc7bbdf12cab63d39fd1df4b1cb013
-lib/codeql/rust/generated/Field.qll c3249b8dd1aed1978077875fbd6090327d431af8cf8888b432cacfa33b76f976 0977ff2fd039f4d6a82ce209d7a7d60a0747a1a3a29be69cf3f136f76429c917
+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/If.qll b8040f4bdc6ca2db2cf0435edd9aca432d1ba5f36170f5588a7746f0e4174c51 6033f72ff2d0d3b640b0ef8399d8ef39bc1eec33242a1567cd7dc5ccd2463797
-lib/codeql/rust/generated/IfLet.qll 8a1b4c0d60cd89093c75d97a225691fa6044fdf6828a14fbf9ead7c9d2445f54 b00937d2507e575403074712cd84298b78d0cc0a1dcf7be65e8c893b2b729724
-lib/codeql/rust/generated/Index.qll f1b78db475006a0779a079f9600987932e638bcfaf35ce4e9b2b872798e35d50 7fa2b22497c3bd80161f7e3ef5477c82a0d4f961dce557ed3fd1a62d9f9328f7
-lib/codeql/rust/generated/InlineAsm.qll 18d8e206d226779d45c27c83e59fdf21ea4fe55969a9d4edf2e91e58877b5d35 723a4d0293a1df9be124b6aae340cb2814e4be0dc01dec95d001e6f986e0e84c
+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/Let.qll 2cdec11bcb64d8c5c9db9ff3c8fff41fc4e5e705c0ff4327ae053ff10579fb6d c7e1742274635ded0088acdfe8cbc9e9d967f27e833ac8a1a37e3a06d207f004
+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/Literal.qll eba217bbd4917c3674406c9538a0114d77d04f23467c4a362898a3020cb7d999 eba217bbd4917c3674406c9538a0114d77d04f23467c4a362898a3020cb7d999
+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/Loop.qll 25e4ed09d3f47980cd9d0974cf3f0c0f73ea6177d5c81380a4346fc5ccfcc3d3 3565a431522b753736c8e880a40524870a92a9b6b2101a25c40232c2b0f20493
-lib/codeql/rust/generated/Match.qll e0dd9a39cfcb5cd56efd89c3c009a62ff39c887511ba2962dfeed978830b5000 7378a8a30d7bde2a06a23e7037bddbd64d656ec047ba18142d22086cc7d7da32
+lib/codeql/rust/generated/LoopExpr.qll e9304e282a97984e147b92ec7061c98fde238a8691e945e4cb775ccf34c27b0c 65b859e44e83bddb710d4ce9e5ab1346b98eaaa46509671776b75c9e8f1c1667
 lib/codeql/rust/generated/MatchArm.qll 5ad0dc254b6d58ccd856e4235b68ca0226a898c33f1f6b6fe7b48266a01ca627 f519af39f45e820eb3a70cefb0e4dfb541c3cf17952c00c6dd7e59f854a629bd
-lib/codeql/rust/generated/MethodCall.qll 1d7afd5e8795b89f3cd20569fe7e0b7fd339aa178ed6ecb2a3a9cadd1a49eede 7a6396ce629a46db16de523fd39e2bb2c56837df80990ff1dd3bdfe242c20761
+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/OffsetOf.qll c5c7218a0dfa6636a4b3e4218969638cc267db94a966b19fbced0ba6f85dbd0e 6c8fac4cd343073ee0ed48498deb7faa65a876776d9ca0a98e51350fead5c8ac
+lib/codeql/rust/generated/OffsetOfExpr.qll 58dfd632efcb48de7fe6ffbcb2192fcf95bfabdb407a751133f63a0e32ae7489 21ebb1b3d66849fc21c04083cfa751eb56c55809cd52664020bd61ccfbe5ea68
 lib/codeql/rust/generated/OrPat.qll f8fe5c7b83a08dabcc530484a696274930040ea13501ae20f1426faeec67bcf0 f3adb3148890531b698570a48740335983a5e81977ba4ac651778f940f184398
-lib/codeql/rust/generated/ParentChild.qll 2edf7c0be4bbb2ffcd8133db21850fabf8e87badf7b4595d1bab258d68da3626 5bcc7154e175e4c96b61b47a681b569950612ec168b7ca3ec7368642c3ad3c9d
+lib/codeql/rust/generated/ParentChild.qll 956f55ac17d66926c59f76d391b75c30767d236b145d6ae402f4308fa22a7d01 dd3cabb5b4a9ba42be60345f445cde18b0d7be934aeb94d7312eeef122e148d2
 lib/codeql/rust/generated/Pat.qll fe1c72856442dbab5655eff93f86c2cbce8d69d9fa1f99a0f9203061ea1112a4 d85d86e8b6c48df733589d186f610b1cd9086629180701e017774bddc62402c7
-lib/codeql/rust/generated/Path.qll ca8878cd96c31ad9238a1d52487e094863d5abba825d189e0ea6f8d674194b75 ca8878cd96c31ad9238a1d52487e094863d5abba825d189e0ea6f8d674194b75
-lib/codeql/rust/generated/PathPat.qll 5869c513e1d0cb689589e2c72f3feda18b0f246d9b03304d8c0f9237f0300524 5869c513e1d0cb689589e2c72f3feda18b0f246d9b03304d8c0f9237f0300524
+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/Range.qll 6278d78c7fba390f51b107892262f9c679c8a31695861a64268e9b74c9575e46 2cb49b0d5d4281c10bdd7ddf187f144cd8490cd792218e977c4108ba98883e06
+lib/codeql/rust/generated/RangeExpr.qll f499d8c1f260d6262a55c1f3640aaee832ed8c9aac922cb2e05fefbca4509053 a01563640bc23fbce9d33da756bc209fd16155dc76a7fed4ba325979723f48a5
 lib/codeql/rust/generated/RangePat.qll 6ec95f6cb9c4bd93b38990bb1e3b89b526624305ac6ee7b94e6fb0a2f3db28fc 0e193f3816a7587d5103dba421bc2bf22b869522353d4e3f43d49a792eac6cf4
-lib/codeql/rust/generated/Raw.qll cf445683a0861aff0c62b0cb8ae398ef54a7b66f9bbe55aebadc8db890a19209 3b3a19a797ea8b9120b6399a7d39d45c1a130d4bad383583d7c80d82bd1af75e
-lib/codeql/rust/generated/RecordLit.qll ae3c644237abab89e0443dfcf584906a9714792be755ce3f9fcdae5958024243 ae3c644237abab89e0443dfcf584906a9714792be755ce3f9fcdae5958024243
-lib/codeql/rust/generated/RecordPat.qll 8c206be87b5738c6107db72cbe4d97a67e55060e92c0a3148fad84092d70f5e7 8c206be87b5738c6107db72cbe4d97a67e55060e92c0a3148fad84092d70f5e7
-lib/codeql/rust/generated/Ref.qll d26cc357f65fb51a5c07863406f732debe3dc02542b415b281ec582efa08a362 9d62dd9a99e158abc7b42c4e011a5dd0db4dfbce25ab6fe5c600354c18a236bd
+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/Repeat.qll ba4a6b643a6d16924b138a1a585fe059d8d094592fa49329e4061ee18c31abc5 4be73736804193d127f968fa6cef1a264753d079f325d8724d258f16df1f3286
-lib/codeql/rust/generated/Return.qll 9664cd51675a9a6ddfe7795b79f491c3834588e0bbc3b25863c621486f46a5f7 b38067c9bbcb0c4a4d2b59d76e81afcca7bc1b72caea91c1a79a7b7526390511
+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 cf37698f44ca6786d3067ab9bc2501664988903cdfe5265aa78838727caca966 1d06d446f064da7e11fb7779030be0f00e5e10a3618e4148c50c0932a090632a
-lib/codeql/rust/generated/SynthConstructors.qll cf79523cb4d14dfcc92c7531e024a966139c99efc170cb86f2035b595c1d5bfd cf79523cb4d14dfcc92c7531e024a966139c99efc170cb86f2035b595c1d5bfd
-lib/codeql/rust/generated/Tuple.qll 3fde94f0c23c6af6bcb58d0245a3cd0a8bbd6ef7999fbeed805baf2615e6226d c1aa7fc201aebb34dc6cd7760e817032b86fd16b8facac450c74deda860bc821
-lib/codeql/rust/generated/TuplePat.qll fdb2c66fe6291106fe125de6a91c4d74b2c715d276c2fee9751d0523b618d095 330098460ccac28479a2b522048d6f1191bf01b40b3eceef4adf722c01c8360b
-lib/codeql/rust/generated/TupleStructPat.qll 955e720b880bb9699ac402edc6774bb9aff4eb2fdf08d08b72f7db4ef4673b36 955e720b880bb9699ac402edc6774bb9aff4eb2fdf08d08b72f7db4ef4673b36
+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/UnaryOp.qll fa587434c234c68606e3d0e32f6f07f89fa468dc97b582242f42c23c009e489a cef0fcfff7527435486b4ba642c5c5d5a17935b41b7388e70311646195bcf5fc
-lib/codeql/rust/generated/Underscore.qll d9980518479f771e164e4fc8d4c180f2a16691afbea65aa163939bae89e9005d d9980518479f771e164e4fc8d4c180f2a16691afbea65aa163939bae89e9005d
+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/UnsafeBlock.qll 2a968ab223354bd81527fe53c59d02364f4389536fb75da3347771e1cf798560 2a968ab223354bd81527fe53c59d02364f4389536fb75da3347771e1cf798560
+lib/codeql/rust/generated/UnsafeBlockExpr.qll 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e 8464597373ea46f6391394f02c4ceb93ffe8441b434e6e71907b0a3369f72d8e
 lib/codeql/rust/generated/WildPat.qll 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8 8a2cede00ac2941cb94e294ffa81ada9ae6e61d8d8a720ce4f288740345802f8
-lib/codeql/rust/generated/Yeet.qll 41b05d32a1b93cee770d6706cc044efe8ce57f11ae2f009c59666264cd1aaec1 8a6c8a1ae59e5a7e1b64abea85f6362c0460cbd5fcace1520b213ef5e08331ef
-lib/codeql/rust/generated/Yield.qll afefea932d770b61b633feeaa05973943c2bb45ea3cd4f960a0be1bbce33a405 c975fba823b05ad40b3c1bd908880e65511b59f9e6882fa207009194a45134a0
+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

rust/ql/.gitattributes

@@ -1,214 +1,225 @@
 /.generated.list linguist-generated
 /.gitattributes linguist-generated
-/lib/codeql/rust/elements/Array.qll linguist-generated
+/lib/codeql/rust/elements/ArrayExpr.qll linguist-generated
 /lib/codeql/rust/elements/AstNode.qll linguist-generated
-/lib/codeql/rust/elements/AsyncBlock.qll linguist-generated
-/lib/codeql/rust/elements/AsyncBlockConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Await.qll linguist-generated
-/lib/codeql/rust/elements/AwaitConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Become.qll linguist-generated
-/lib/codeql/rust/elements/BecomeConstructor.qll linguist-generated
-/lib/codeql/rust/elements/BinaryOp.qll linguist-generated
-/lib/codeql/rust/elements/BinaryOpConstructor.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/Block.qll linguist-generated
-/lib/codeql/rust/elements/BlockBase.qll linguist-generated
-/lib/codeql/rust/elements/BlockConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Box.qll linguist-generated
-/lib/codeql/rust/elements/BoxConstructor.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/Break.qll linguist-generated
-/lib/codeql/rust/elements/BreakConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Call.qll linguist-generated
-/lib/codeql/rust/elements/CallConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Cast.qll linguist-generated
-/lib/codeql/rust/elements/CastConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Closure.qll linguist-generated
-/lib/codeql/rust/elements/ClosureConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Const.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/ConstConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Continue.qll linguist-generated
-/lib/codeql/rust/elements/ContinueConstructor.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/ElementList.qll linguist-generated
-/lib/codeql/rust/elements/ElementListConstructor.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/Field.qll linguist-generated
-/lib/codeql/rust/elements/FieldConstructor.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/If.qll linguist-generated
-/lib/codeql/rust/elements/IfConstructor.qll linguist-generated
-/lib/codeql/rust/elements/IfLet.qll linguist-generated
-/lib/codeql/rust/elements/IfLetConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Index.qll linguist-generated
-/lib/codeql/rust/elements/IndexConstructor.qll linguist-generated
-/lib/codeql/rust/elements/InlineAsm.qll linguist-generated
-/lib/codeql/rust/elements/InlineAsmConstructor.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/Let.qll linguist-generated
-/lib/codeql/rust/elements/LetConstructor.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/Literal.qll linguist-generated
-/lib/codeql/rust/elements/LiteralConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Loop.qll linguist-generated
-/lib/codeql/rust/elements/LoopConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Match.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/MatchConstructor.qll linguist-generated
-/lib/codeql/rust/elements/MethodCall.qll linguist-generated
-/lib/codeql/rust/elements/MethodCallConstructor.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/OffsetOf.qll linguist-generated
-/lib/codeql/rust/elements/OffsetOfConstructor.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/Path.qll linguist-generated
-/lib/codeql/rust/elements/PathConstructor.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/Range.qll linguist-generated
-/lib/codeql/rust/elements/RangeConstructor.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/RecordLit.qll linguist-generated
-/lib/codeql/rust/elements/RecordLitConstructor.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/Ref.qll linguist-generated
-/lib/codeql/rust/elements/RefConstructor.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/Repeat.qll linguist-generated
-/lib/codeql/rust/elements/RepeatConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Return.qll linguist-generated
-/lib/codeql/rust/elements/ReturnConstructor.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/Tuple.qll linguist-generated
-/lib/codeql/rust/elements/TupleConstructor.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/UnaryOp.qll linguist-generated
-/lib/codeql/rust/elements/UnaryOpConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Underscore.qll linguist-generated
-/lib/codeql/rust/elements/UnderscoreConstructor.qll linguist-generated
-/lib/codeql/rust/elements/UnsafeBlock.qll linguist-generated
-/lib/codeql/rust/elements/UnsafeBlockConstructor.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/Yeet.qll linguist-generated
-/lib/codeql/rust/elements/YeetConstructor.qll linguist-generated
-/lib/codeql/rust/elements/Yield.qll linguist-generated
-/lib/codeql/rust/elements/YieldConstructor.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/Array.qll linguist-generated
+/lib/codeql/rust/generated/ArrayExpr.qll linguist-generated
 /lib/codeql/rust/generated/AstNode.qll linguist-generated
-/lib/codeql/rust/generated/AsyncBlock.qll linguist-generated
-/lib/codeql/rust/generated/Await.qll linguist-generated
-/lib/codeql/rust/generated/Become.qll linguist-generated
-/lib/codeql/rust/generated/BinaryOp.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/Block.qll linguist-generated
-/lib/codeql/rust/generated/BlockBase.qll linguist-generated
-/lib/codeql/rust/generated/Box.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/Break.qll linguist-generated
-/lib/codeql/rust/generated/Call.qll linguist-generated
-/lib/codeql/rust/generated/Cast.qll linguist-generated
-/lib/codeql/rust/generated/Closure.qll linguist-generated
-/lib/codeql/rust/generated/Const.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/Continue.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/ElementList.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/Field.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/If.qll linguist-generated
-/lib/codeql/rust/generated/IfLet.qll linguist-generated
-/lib/codeql/rust/generated/Index.qll linguist-generated
-/lib/codeql/rust/generated/InlineAsm.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/Let.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/Literal.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/Loop.qll linguist-generated
-/lib/codeql/rust/generated/Match.qll linguist-generated
+/lib/codeql/rust/generated/LoopExpr.qll linguist-generated
 /lib/codeql/rust/generated/MatchArm.qll linguist-generated
-/lib/codeql/rust/generated/MethodCall.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/OffsetOf.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/Path.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/Range.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/RecordLit.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/Ref.qll linguist-generated
+/lib/codeql/rust/generated/RefExpr.qll linguist-generated
 /lib/codeql/rust/generated/RefPat.qll linguist-generated
-/lib/codeql/rust/generated/Repeat.qll linguist-generated
-/lib/codeql/rust/generated/Return.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/Tuple.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/UnaryOp.qll linguist-generated
-/lib/codeql/rust/generated/Underscore.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/UnsafeBlock.qll linguist-generated
+/lib/codeql/rust/generated/UnsafeBlockExpr.qll linguist-generated
 /lib/codeql/rust/generated/WildPat.qll linguist-generated
-/lib/codeql/rust/generated/Yeet.qll linguist-generated
-/lib/codeql/rust/generated/Yield.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

rust/ql/lib/codeql/rust/elements.qll

@@ -3,76 +3,79 @@
  * This module exports all modules providing `Element` subclasses.
  */
 
-import codeql.rust.elements.Array
+import codeql.rust.elements.ArrayExpr
 import codeql.rust.elements.AstNode
-import codeql.rust.elements.AsyncBlock
-import codeql.rust.elements.Await
-import codeql.rust.elements.Become
-import codeql.rust.elements.BinaryOp
+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.Block
-import codeql.rust.elements.BlockBase
-import codeql.rust.elements.Box
+import codeql.rust.elements.BlockExpr
+import codeql.rust.elements.BlockExprBase
+import codeql.rust.elements.BoxExpr
 import codeql.rust.elements.BoxPat
-import codeql.rust.elements.Break
-import codeql.rust.elements.Call
-import codeql.rust.elements.Cast
-import codeql.rust.elements.Closure
-import codeql.rust.elements.Const
+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.Continue
+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.ElementList
+import codeql.rust.elements.ElementListExpr
 import codeql.rust.elements.Expr
 import codeql.rust.elements.ExprStmt
-import codeql.rust.elements.Field
+import codeql.rust.elements.FieldExpr
 import codeql.rust.elements.File
 import codeql.rust.elements.Function
-import codeql.rust.elements.If
-import codeql.rust.elements.IfLet
-import codeql.rust.elements.Index
-import codeql.rust.elements.InlineAsm
+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.Let
+import codeql.rust.elements.LetExpr
+import codeql.rust.elements.LetStmt
 import codeql.rust.elements.LitPat
-import codeql.rust.elements.Literal
+import codeql.rust.elements.LiteralExpr
 import codeql.rust.elements.Locatable
 import codeql.rust.elements.Location
-import codeql.rust.elements.Loop
-import codeql.rust.elements.Match
+import codeql.rust.elements.LoopExpr
 import codeql.rust.elements.MatchArm
-import codeql.rust.elements.MethodCall
+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.OffsetOf
+import codeql.rust.elements.OffsetOfExpr
 import codeql.rust.elements.OrPat
 import codeql.rust.elements.Pat
-import codeql.rust.elements.Path
+import codeql.rust.elements.PathExpr
 import codeql.rust.elements.PathPat
-import codeql.rust.elements.Range
+import codeql.rust.elements.RangeExpr
 import codeql.rust.elements.RangePat
-import codeql.rust.elements.RecordLit
+import codeql.rust.elements.RecordFieldPat
+import codeql.rust.elements.RecordLitExpr
+import codeql.rust.elements.RecordLitField
 import codeql.rust.elements.RecordPat
-import codeql.rust.elements.Ref
+import codeql.rust.elements.RefExpr
 import codeql.rust.elements.RefPat
-import codeql.rust.elements.Repeat
-import codeql.rust.elements.Return
+import codeql.rust.elements.RepeatExpr
+import codeql.rust.elements.ReturnExpr
 import codeql.rust.elements.SlicePat
 import codeql.rust.elements.Stmt
-import codeql.rust.elements.Tuple
+import codeql.rust.elements.TupleExpr
 import codeql.rust.elements.TuplePat
 import codeql.rust.elements.TupleStructPat
 import codeql.rust.elements.TypeRef
-import codeql.rust.elements.UnaryOp
-import codeql.rust.elements.Underscore
+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.UnsafeBlock
+import codeql.rust.elements.UnsafeBlockExpr
 import codeql.rust.elements.WildPat
-import codeql.rust.elements.Yeet
-import codeql.rust.elements.Yield
+import codeql.rust.elements.YeetExpr
+import codeql.rust.elements.YieldExpr

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 { }

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 { }

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() }

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 { }

rust/ql/lib/codeql/rust/elements/AwaitExprConstructor.qll

@@ -1,14 +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
- *  `InlineAsm` synthesized instances.
+ *  `AwaitExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `InlineAsm` synthesized instances.
+ *  The characteristic predicate of `AwaitExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructInlineAsm(Raw::InlineAsm id) { any() }
+predicate constructAwaitExpr(Raw::AwaitExpr id) { any() }

rust/ql/lib/codeql/rust/elements/BecomeExpr.qll

@@ -1,8 +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 `AsyncBlock`.
+ * This module provides a hand-modifiable wrapper around the generated class `BecomeExpr`.
  */
 
-private import codeql.rust.generated.AsyncBlock
+private import codeql.rust.generated.BecomeExpr
 
-class AsyncBlock extends Generated::AsyncBlock { }
+class BecomeExpr extends Generated::BecomeExpr { }

rust/ql/lib/codeql/rust/elements/BecomeExprConstructor.qll

@@ -1,14 +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
- *  `MethodCall` synthesized instances.
+ *  `BecomeExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `MethodCall` synthesized instances.
+ *  The characteristic predicate of `BecomeExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructMethodCall(Raw::MethodCall id) { any() }
+predicate constructBecomeExpr(Raw::BecomeExpr id) { any() }

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 { }

rust/ql/lib/codeql/rust/elements/BinaryOpExprConstructor.qll

@@ -1,14 +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
- *  `Await` synthesized instances.
+ *  `BinaryOpExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Await` synthesized instances.
+ *  The characteristic predicate of `BinaryOpExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructAwait(Raw::Await id) { any() }
+predicate constructBinaryOpExpr(Raw::BinaryOpExpr id) { any() }

rust/ql/lib/codeql/rust/elements/BlockBase.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `BlockBase`.
- */
-
-private import codeql.rust.generated.BlockBase
-
-class BlockBase extends Generated::BlockBase { }

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 { }

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 { }

rust/ql/lib/codeql/rust/elements/BlockExprConstructor.qll

@@ -1,14 +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
- *  `RecordLit` synthesized instances.
+ *  `BlockExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `RecordLit` synthesized instances.
+ *  The characteristic predicate of `BlockExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructRecordLit(Raw::RecordLit id) { any() }
+predicate constructBlockExpr(Raw::BlockExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Box.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Box`.
- */
-
-private import codeql.rust.generated.Box
-
-class Box extends Generated::Box { }

rust/ql/lib/codeql/rust/elements/BoxExpr.qll

@@ -1,8 +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 `Block`.
+ * This module provides a hand-modifiable wrapper around the generated class `BoxExpr`.
  */
 
-private import codeql.rust.generated.Block
+private import codeql.rust.generated.BoxExpr
 
-class Block extends Generated::Block { }
+class BoxExpr extends Generated::BoxExpr { }

rust/ql/lib/codeql/rust/elements/BoxExprConstructor.qll

@@ -1,14 +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
- *  `Closure` synthesized instances.
+ *  `BoxExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Closure` synthesized instances.
+ *  The characteristic predicate of `BoxExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructClosure(Raw::Closure id) { any() }
+predicate constructBoxExpr(Raw::BoxExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Break.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Break`.
- */
-
-private import codeql.rust.generated.Break
-
-class Break extends Generated::Break { }

rust/ql/lib/codeql/rust/elements/BreakConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Break` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Break` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructBreak(Raw::Break id) { any() }

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 { }

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() }

rust/ql/lib/codeql/rust/elements/Call.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Call`.
- */
-
-private import codeql.rust.generated.Call
-
-class Call extends Generated::Call { }

rust/ql/lib/codeql/rust/elements/CallConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Call` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Call` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructCall(Raw::Call id) { any() }

rust/ql/lib/codeql/rust/elements/CallExpr.qll

@@ -1,8 +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 `BinaryOp`.
+ * This module provides a hand-modifiable wrapper around the generated class `CallExpr`.
  */
 
-private import codeql.rust.generated.BinaryOp
+private import codeql.rust.generated.CallExpr
 
-class BinaryOp extends Generated::BinaryOp { }
+class CallExpr extends Generated::CallExpr { }

rust/ql/lib/codeql/rust/elements/CallExprConstructor.qll

@@ -1,14 +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
- *  `Continue` synthesized instances.
+ *  `CallExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Continue` synthesized instances.
+ *  The characteristic predicate of `CallExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructContinue(Raw::Continue id) { any() }
+predicate constructCallExpr(Raw::CallExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Cast.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Cast`.
- */
-
-private import codeql.rust.generated.Cast
-
-class Cast extends Generated::Cast { }

rust/ql/lib/codeql/rust/elements/CastConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Cast` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Cast` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructCast(Raw::Cast id) { any() }

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 { }

rust/ql/lib/codeql/rust/elements/CastExprConstructor.qll

@@ -1,14 +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
- *  `OffsetOf` synthesized instances.
+ *  `CastExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `OffsetOf` synthesized instances.
+ *  The characteristic predicate of `CastExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructOffsetOf(Raw::OffsetOf id) { any() }
+predicate constructCastExpr(Raw::CastExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Closure.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Closure`.
- */
-
-private import codeql.rust.generated.Closure
-
-class Closure extends Generated::Closure { }

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 { }

rust/ql/lib/codeql/rust/elements/ClosureExprConstructor.qll

@@ -1,14 +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
- *  `ElementList` synthesized instances.
+ *  `ClosureExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `ElementList` synthesized instances.
+ *  The characteristic predicate of `ClosureExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructElementList(Raw::ElementList id) { any() }
+predicate constructClosureExpr(Raw::ClosureExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Const.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Const`.
- */
-
-private import codeql.rust.generated.Const
-
-class Const extends Generated::Const { }

rust/ql/lib/codeql/rust/elements/ConstConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Const` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Const` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructConst(Raw::Const id) { any() }

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 { }

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() }

rust/ql/lib/codeql/rust/elements/Continue.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Continue`.
- */
-
-private import codeql.rust.generated.Continue
-
-class Continue extends Generated::Continue { }

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 { }

rust/ql/lib/codeql/rust/elements/ContinueExprConstructor.qll

@@ -1,14 +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
- *  `Become` synthesized instances.
+ *  `ContinueExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Become` synthesized instances.
+ *  The characteristic predicate of `ContinueExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructBecome(Raw::Become id) { any() }
+predicate constructContinueExpr(Raw::ContinueExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Element.qll

@@ -5,5 +5,7 @@
 private import codeql.rust.generated.Element
 
 class Element extends Generated::Element {
+  override string toString() { result = this.getAPrimaryQlClass() }
+
   predicate isUnknown() { none() } // compatibility with test generation, to be fixed
 }

rust/ql/lib/codeql/rust/elements/ElementList.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `ElementList`.
- */
-
-private import codeql.rust.generated.ElementList
-
-class ElementList extends Generated::ElementList { }

rust/ql/lib/codeql/rust/elements/ElementListExpr.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 `ElementListExpr`.
+ */
+
+private import codeql.rust.generated.ElementListExpr
+
+class ElementListExpr extends Generated::ElementListExpr { }

rust/ql/lib/codeql/rust/elements/ElementListExprConstructor.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
+ *  `ElementListExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `ElementListExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructElementListExpr(Raw::ElementListExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Field.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Field`.
- */
-
-private import codeql.rust.generated.Field
-
-class Field extends Generated::Field { }

rust/ql/lib/codeql/rust/elements/FieldConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Field` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Field` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructField(Raw::Field id) { any() }

rust/ql/lib/codeql/rust/elements/FieldExpr.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 `FieldExpr`.
+ */
+
+private import codeql.rust.generated.FieldExpr
+
+class FieldExpr extends Generated::FieldExpr { }

rust/ql/lib/codeql/rust/elements/FieldExprConstructor.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
+ *  `FieldExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `FieldExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructFieldExpr(Raw::FieldExpr id) { any() }

rust/ql/lib/codeql/rust/elements/If.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `If`.
- */
-
-private import codeql.rust.generated.If
-
-class If extends Generated::If { }

rust/ql/lib/codeql/rust/elements/IfConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `If` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `If` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructIf(Raw::If id) { any() }

rust/ql/lib/codeql/rust/elements/IfExpr.qll

@@ -1,8 +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 `Array`.
+ * This module provides a hand-modifiable wrapper around the generated class `IfExpr`.
  */
 
-private import codeql.rust.generated.Array
+private import codeql.rust.generated.IfExpr
 
-class Array extends Generated::Array { }
+class IfExpr extends Generated::IfExpr { }

rust/ql/lib/codeql/rust/elements/IfExprConstructor.qll

@@ -1,14 +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
- *  `Repeat` synthesized instances.
+ *  `IfExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Repeat` synthesized instances.
+ *  The characteristic predicate of `IfExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructRepeat(Raw::Repeat id) { any() }
+predicate constructIfExpr(Raw::IfExpr id) { any() }

rust/ql/lib/codeql/rust/elements/IfLet.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `IfLet`.
- */
-
-private import codeql.rust.generated.IfLet
-
-class IfLet extends Generated::IfLet { }

rust/ql/lib/codeql/rust/elements/IfLetConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `IfLet` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `IfLet` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructIfLet(Raw::IfLet id) { any() }

rust/ql/lib/codeql/rust/elements/Index.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Index`.
- */
-
-private import codeql.rust.generated.Index
-
-class Index extends Generated::Index { }

rust/ql/lib/codeql/rust/elements/IndexConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Index` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Index` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructIndex(Raw::Index id) { any() }

rust/ql/lib/codeql/rust/elements/IndexExpr.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 `IndexExpr`.
+ */
+
+private import codeql.rust.generated.IndexExpr
+
+class IndexExpr extends Generated::IndexExpr { }

rust/ql/lib/codeql/rust/elements/IndexExprConstructor.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
+ *  `IndexExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `IndexExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructIndexExpr(Raw::IndexExpr id) { any() }

rust/ql/lib/codeql/rust/elements/InlineAsm.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `InlineAsm`.
- */
-
-private import codeql.rust.generated.InlineAsm
-
-class InlineAsm extends Generated::InlineAsm { }

rust/ql/lib/codeql/rust/elements/InlineAsmExpr.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 `InlineAsmExpr`.
+ */
+
+private import codeql.rust.generated.InlineAsmExpr
+
+class InlineAsmExpr extends Generated::InlineAsmExpr { }

rust/ql/lib/codeql/rust/elements/InlineAsmExprConstructor.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
+ *  `InlineAsmExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `InlineAsmExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructInlineAsmExpr(Raw::InlineAsmExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Let.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Let`.
- */
-
-private import codeql.rust.generated.Let
-
-class Let extends Generated::Let { }

rust/ql/lib/codeql/rust/elements/LetConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Let` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Let` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructLet(Raw::Let id) { any() }

rust/ql/lib/codeql/rust/elements/LetExpr.qll

@@ -1,8 +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 `Become`.
+ * This module provides a hand-modifiable wrapper around the generated class `LetExpr`.
  */
 
-private import codeql.rust.generated.Become
+private import codeql.rust.generated.LetExpr
 
-class Become extends Generated::Become { }
+class LetExpr extends Generated::LetExpr { }

rust/ql/lib/codeql/rust/elements/LetExprConstructor.qll

@@ -1,14 +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
- *  `Literal` synthesized instances.
+ *  `LetExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Literal` synthesized instances.
+ *  The characteristic predicate of `LetExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructLiteral(Raw::Literal id) { any() }
+predicate constructLetExpr(Raw::LetExpr id) { any() }

rust/ql/lib/codeql/rust/elements/LetStmt.qll

@@ -1,8 +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 `Await`.
+ * This module provides a hand-modifiable wrapper around the generated class `LetStmt`.
  */
 
-private import codeql.rust.generated.Await
+private import codeql.rust.generated.LetStmt
 
-class Await extends Generated::Await { }
+class LetStmt extends Generated::LetStmt { }

rust/ql/lib/codeql/rust/elements/LetStmtConstructor.qll

@@ -1,14 +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
- *  `UnaryOp` synthesized instances.
+ *  `LetStmt` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `UnaryOp` synthesized instances.
+ *  The characteristic predicate of `LetStmt` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructUnaryOp(Raw::UnaryOp id) { any() }
+predicate constructLetStmt(Raw::LetStmt id) { any() }

rust/ql/lib/codeql/rust/elements/Literal.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Literal`.
- */
-
-private import codeql.rust.generated.Literal
-
-class Literal extends Generated::Literal { }

rust/ql/lib/codeql/rust/elements/LiteralExpr.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 `LiteralExpr`.
+ */
+
+private import codeql.rust.generated.LiteralExpr
+
+class LiteralExpr extends Generated::LiteralExpr { }

rust/ql/lib/codeql/rust/elements/LiteralExprConstructor.qll

@@ -1,14 +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
- *  `UnsafeBlock` synthesized instances.
+ *  `LiteralExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `UnsafeBlock` synthesized instances.
+ *  The characteristic predicate of `LiteralExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructUnsafeBlock(Raw::UnsafeBlock id) { any() }
+predicate constructLiteralExpr(Raw::LiteralExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Loop.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Loop`.
- */
-
-private import codeql.rust.generated.Loop
-
-class Loop extends Generated::Loop { }

rust/ql/lib/codeql/rust/elements/LoopConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Loop` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Loop` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructLoop(Raw::Loop id) { any() }

rust/ql/lib/codeql/rust/elements/LoopExpr.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 `LoopExpr`.
+ */
+
+private import codeql.rust.generated.LoopExpr
+
+class LoopExpr extends Generated::LoopExpr { }

rust/ql/lib/codeql/rust/elements/LoopExprConstructor.qll

@@ -1,14 +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
- *  `BinaryOp` synthesized instances.
+ *  `LoopExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `BinaryOp` synthesized instances.
+ *  The characteristic predicate of `LoopExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructBinaryOp(Raw::BinaryOp id) { any() }
+predicate constructLoopExpr(Raw::LoopExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Match.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Match`.
- */
-
-private import codeql.rust.generated.Match
-
-class Match extends Generated::Match { }

rust/ql/lib/codeql/rust/elements/MatchConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Match` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Match` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructMatch(Raw::Match id) { any() }

rust/ql/lib/codeql/rust/elements/MatchExpr.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 `MatchExpr`.
+ */
+
+private import codeql.rust.generated.MatchExpr
+
+class MatchExpr extends Generated::MatchExpr { }

rust/ql/lib/codeql/rust/elements/MatchExprConstructor.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
+ *  `MatchExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `MatchExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructMatchExpr(Raw::MatchExpr id) { any() }

rust/ql/lib/codeql/rust/elements/MethodCall.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `MethodCall`.
- */
-
-private import codeql.rust.generated.MethodCall
-
-class MethodCall extends Generated::MethodCall { }

rust/ql/lib/codeql/rust/elements/MethodCallExpr.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 `MethodCallExpr`.
+ */
+
+private import codeql.rust.generated.MethodCallExpr
+
+class MethodCallExpr extends Generated::MethodCallExpr { }

rust/ql/lib/codeql/rust/elements/MethodCallExprConstructor.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
+ *  `MethodCallExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `MethodCallExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructMethodCallExpr(Raw::MethodCallExpr id) { any() }

rust/ql/lib/codeql/rust/elements/OffsetOf.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `OffsetOf`.
- */
-
-private import codeql.rust.generated.OffsetOf
-
-class OffsetOf extends Generated::OffsetOf { }

rust/ql/lib/codeql/rust/elements/OffsetOfExpr.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 `OffsetOfExpr`.
+ */
+
+private import codeql.rust.generated.OffsetOfExpr
+
+class OffsetOfExpr extends Generated::OffsetOfExpr { }

rust/ql/lib/codeql/rust/elements/OffsetOfExprConstructor.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
+ *  `OffsetOfExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+
+private import codeql.rust.generated.Raw
+
+/**
+ *  The characteristic predicate of `OffsetOfExpr` synthesized instances.
+ *  INTERNAL: Do not use.
+ */
+predicate constructOffsetOfExpr(Raw::OffsetOfExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Path.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Path`.
- */
-
-private import codeql.rust.generated.Path
-
-class Path extends Generated::Path { }

rust/ql/lib/codeql/rust/elements/PathConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Path` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Path` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructPath(Raw::Path id) { any() }

rust/ql/lib/codeql/rust/elements/PathExpr.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 `PathExpr`.
+ */
+
+private import codeql.rust.generated.PathExpr
+
+class PathExpr extends Generated::PathExpr { }

rust/ql/lib/codeql/rust/elements/PathExprConstructor.qll

@@ -1,14 +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
- *  `Block` synthesized instances.
+ *  `PathExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
 
 private import codeql.rust.generated.Raw
 
 /**
- *  The characteristic predicate of `Block` synthesized instances.
+ *  The characteristic predicate of `PathExpr` synthesized instances.
  *  INTERNAL: Do not use.
  */
-predicate constructBlock(Raw::Block id) { any() }
+predicate constructPathExpr(Raw::PathExpr id) { any() }

rust/ql/lib/codeql/rust/elements/Range.qll

@@ -1,8 +0,0 @@
-// generated by codegen, remove this comment if you wish to edit this file
-/**
- * This module provides a hand-modifiable wrapper around the generated class `Range`.
- */
-
-private import codeql.rust.generated.Range
-
-class Range extends Generated::Range { }

rust/ql/lib/codeql/rust/elements/RangeConstructor.qll

@@ -1,14 +0,0 @@
-// 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
- *  `Range` synthesized instances.
- *  INTERNAL: Do not use.
- */
-
-private import codeql.rust.generated.Raw
-
-/**
- *  The characteristic predicate of `Range` synthesized instances.
- *  INTERNAL: Do not use.
- */
-predicate constructRange(Raw::Range id) { any() }