From f05bed685dded2eb72f31c20fc049fcdb455d42c Mon Sep 17 00:00:00 2001 From: Arthur Baars Date: Thu, 15 May 2025 18:49:15 +0200 Subject: [PATCH] Rust: remove module data from Crate elements --- rust/extractor/src/crate_graph.rs | 1540 +---------------- rust/extractor/src/generated/.generated.list | 2 +- rust/extractor/src/generated/top.rs | 4 - rust/ql/.generated.list | 8 +- rust/ql/lib/codeql/rust/elements/Crate.qll | 1 - .../elements/internal/generated/Crate.qll | 13 - .../rust/elements/internal/generated/Raw.qll | 5 - rust/ql/lib/rust.dbscheme | 6 - rust/schema/prelude.py | 1 - 9 files changed, 13 insertions(+), 1567 deletions(-) diff --git a/rust/extractor/src/crate_graph.rs b/rust/extractor/src/crate_graph.rs index 8122248aba3..87f8e4e17b4 100644 --- a/rust/extractor/src/crate_graph.rs +++ b/rust/extractor/src/crate_graph.rs @@ -1,46 +1,15 @@ -use crate::{ - generated::{self}, - trap::{self, TrapFile}, -}; -use chalk_ir::FloatTy; -use chalk_ir::IntTy; -use chalk_ir::Scalar; -use chalk_ir::UintTy; +use crate::{generated, trap}; + use itertools::Itertools; use ra_ap_base_db::{Crate, RootQueryDb}; use ra_ap_cfg::CfgAtom; -use ra_ap_hir::{DefMap, ModuleDefId, PathKind, db::HirDatabase}; -use ra_ap_hir::{VariantId, Visibility, db::DefDatabase}; -use ra_ap_hir_def::GenericDefId; -use ra_ap_hir_def::Lookup; -use ra_ap_hir_def::{ - AssocItemId, ConstParamId, LocalModuleId, TypeOrConstParamId, - data::adt::VariantData, - generics::{GenericParams, TypeOrConstParamData}, - item_scope::ImportOrGlob, - item_tree::ImportKind, - nameres::ModuleData, - path::ImportAlias, -}; -use ra_ap_hir_def::{HasModule, visibility::VisibilityExplicitness}; -use ra_ap_hir_def::{ModuleId, resolver::HasResolver}; -use ra_ap_hir_ty::GenericArg; -use ra_ap_hir_ty::ProjectionTyExt; -use ra_ap_hir_ty::TraitRefExt; -use ra_ap_hir_ty::Ty; -use ra_ap_hir_ty::TyExt; -use ra_ap_hir_ty::TyLoweringContext; -use ra_ap_hir_ty::WhereClause; -use ra_ap_hir_ty::from_assoc_type_id; -use ra_ap_hir_ty::{Binders, FnPointer}; -use ra_ap_hir_ty::{Interner, ProjectionTy}; use ra_ap_ide_db::RootDatabase; use ra_ap_vfs::{Vfs, VfsPath}; +use std::hash::Hash; use std::hash::Hasher; use std::{cmp::Ordering, collections::HashMap, path::PathBuf}; -use std::{hash::Hash, vec}; -use tracing::{debug, error}; +use tracing::error; pub fn extract_crate_graph(trap_provider: &trap::TrapFileProvider, db: &RootDatabase, vfs: &Vfs) { let crate_graph = db.all_crates(); @@ -89,16 +58,6 @@ pub fn extract_crate_graph(trap_provider: &trap::TrapFileProvider, db: &RootData continue; } let krate = krate_id.data(db); - let root_module = emit_module( - db, - db.crate_def_map(*krate_id).as_ref(), - "crate", - DefMap::ROOT, - &mut trap, - ); - let file_label = trap.emit_file(root_module_file); - trap.emit_file_only_location(file_label, root_module); - let crate_dependencies: Vec = krate .dependencies .iter() @@ -118,7 +77,6 @@ pub fn extract_crate_graph(trap_provider: &trap::TrapFileProvider, db: &RootData .as_ref() .map(|x| x.canonical_name().to_string()), version: krate_extra.version.to_owned(), - module: Some(root_module), cfg_options: krate_id .cfg_options(db) .into_iter() @@ -129,7 +87,10 @@ pub fn extract_crate_graph(trap_provider: &trap::TrapFileProvider, db: &RootData .map(|dep| trap.emit(dep)) .collect(), }; - trap.emit(element); + let label = trap.emit(element); + let file_label = trap.emit_file(root_module_file); + trap.emit_file_only_location(file_label, label); + trap.commit().unwrap_or_else(|err| { error!( "Failed to write trap file for crate: {}: {}", @@ -141,1491 +102,6 @@ pub fn extract_crate_graph(trap_provider: &trap::TrapFileProvider, db: &RootData } } -fn emit_module( - db: &dyn HirDatabase, - map: &DefMap, - name: &str, - module: LocalModuleId, - trap: &mut TrapFile, -) -> trap::Label { - let module = &map.modules[module]; - let mut items = Vec::new(); - items.extend(emit_module_children(db, map, module, trap)); - items.extend(emit_module_items(db, module, trap)); - items.extend(emit_module_impls(db, module, trap)); - - let name = trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - }); - let item_list = trap.emit(generated::ItemList { - id: trap::TrapId::Star, - attrs: vec![], - items, - }); - let visibility = emit_visibility(db, trap, module.visibility); - trap.emit(generated::Module { - id: trap::TrapId::Star, - name: Some(name), - attrs: vec![], - item_list: Some(item_list), - visibility, - }) -} - -fn emit_module_children( - db: &dyn HirDatabase, - map: &DefMap, - module: &ModuleData, - trap: &mut TrapFile, -) -> Vec> { - module - .children - .iter() - .sorted_by(|a, b| Ord::cmp(&a.0, &b.0)) - .map(|(name, child)| emit_module(db, map, name.as_str(), *child, trap).into()) - .collect() -} - -fn emit_reexport( - db: &dyn HirDatabase, - trap: &mut TrapFile, - uses: &mut HashMap>, - import: ImportOrGlob, - name: &str, -) { - let (use_, idx) = match import { - ImportOrGlob::Glob(import) => (import.use_, import.idx), - ImportOrGlob::Import(import) => (import.use_, import.idx), - }; - let def_db = db.upcast(); - let loc = use_.lookup(def_db); - let use_ = &loc.id.item_tree(def_db)[loc.id.value]; - - use_.use_tree.expand(|id, path, kind, alias| { - if id == idx { - let mut path_components = Vec::new(); - match path.kind { - PathKind::Plain => (), - PathKind::Super(0) => path_components.push("self".to_owned()), - PathKind::Super(n) => { - path_components.extend(std::iter::repeat_n("super".to_owned(), n.into())); - } - PathKind::Crate => path_components.push("crate".to_owned()), - PathKind::Abs => path_components.push("".to_owned()), - PathKind::DollarCrate(crate_id) => { - let crate_extra = crate_id.extra_data(db); - let crate_name = crate_extra - .display_name - .as_ref() - .map(|x| x.canonical_name().to_string()); - path_components.push(crate_name.unwrap_or("crate".to_owned())); - } - } - path_components.extend(path.segments().iter().map(|x| x.as_str().to_owned())); - match kind { - ImportKind::Plain => (), - ImportKind::Glob => path_components.push(name.to_owned()), - ImportKind::TypeOnly => path_components.push("self".to_owned()), - }; - - let alias = alias.map(|alias| match alias { - ImportAlias::Underscore => "_".to_owned(), - ImportAlias::Alias(name) => name.as_str().to_owned(), - }); - let key = format!( - "{} as {}", - path_components.join("::"), - alias.as_ref().unwrap_or(&"".to_owned()) - ); - // prevent duplicate imports - if uses.contains_key(&key) { - return; - } - let rename = alias.map(|name| { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name), - })); - trap.emit(generated::Rename { - id: trap::TrapId::Star, - name, - }) - }); - let path = make_qualified_path(trap, path_components, None); - let use_tree = trap.emit(generated::UseTree { - id: trap::TrapId::Star, - is_glob: false, - path, - rename, - use_tree_list: None, - }); - let visibility = emit_visibility(db, trap, Visibility::Public); - uses.insert( - key, - trap.emit(generated::Use { - id: trap::TrapId::Star, - attrs: vec![], - use_tree: Some(use_tree), - visibility, - }) - .into(), - ); - } - }); -} - -fn emit_module_items( - db: &dyn HirDatabase, - module: &ModuleData, - trap: &mut TrapFile, -) -> Vec> { - let mut items: Vec> = Vec::new(); - let mut uses = HashMap::new(); - let item_scope = &module.scope; - for (name, item) in item_scope.entries() { - let def = item.filter_visibility(|x| matches!(x, ra_ap_hir::Visibility::Public)); - if let Some(ra_ap_hir_def::per_ns::Item { - def: _, - vis: _, - import: Some(import), - }) = def.values - { - emit_reexport(db, trap, &mut uses, import, name.as_str()); - } - if let Some(ra_ap_hir_def::per_ns::Item { - def: value, - vis, - import: None, - }) = def.values - { - match value { - ModuleDefId::FunctionId(function) => { - items.push(emit_function(db, trap, None, function, name).into()); - } - ModuleDefId::ConstId(konst) => { - items.extend( - emit_const(db, trap, None, name.as_str(), konst, vis) - .map(Into::>::into), - ); - } - ModuleDefId::StaticId(statik) => { - items.extend(emit_static(db, name.as_str(), trap, statik, vis)); - } - // Enum variants can only be introduced into the value namespace by an import (`use`) statement - ModuleDefId::EnumVariantId(_) => (), - // Not in the "value" namespace - ModuleDefId::ModuleId(_) - | ModuleDefId::AdtId(_) - | ModuleDefId::TraitId(_) - | ModuleDefId::TraitAliasId(_) - | ModuleDefId::TypeAliasId(_) - | ModuleDefId::BuiltinType(_) - | ModuleDefId::MacroId(_) => (), - } - } - if let Some(ra_ap_hir_def::per_ns::Item { - def: _, - vis: _, - import: Some(import), - }) = def.types - { - // TODO: handle ExternCrate as well? - if let Some(import) = import.import_or_glob() { - emit_reexport(db, trap, &mut uses, import, name.as_str()); - } - } - if let Some(ra_ap_hir_def::per_ns::Item { - def: type_id, - vis, - import: None, - }) = def.types - { - match type_id { - ModuleDefId::AdtId(adt_id) => { - items.extend(emit_adt(db, name.as_str(), trap, adt_id, vis)); - } - ModuleDefId::TraitId(trait_id) => { - items.extend(emit_trait(db, name.as_str(), trap, trait_id, vis)); - } - ModuleDefId::TypeAliasId(type_alias_id_) => items.extend( - emit_type_alias(db, trap, None, name.as_str(), type_alias_id_, vis) - .map(Into::>::into), - ), - ModuleDefId::TraitAliasId(_) => (), - ModuleDefId::BuiltinType(_) => (), - // modules are handled separatedly - ModuleDefId::ModuleId(_) => (), - // Enum variants cannot be declarted, only imported - ModuleDefId::EnumVariantId(_) => (), - // Not in the "types" namespace - ModuleDefId::FunctionId(_) - | ModuleDefId::ConstId(_) - | ModuleDefId::StaticId(_) - | ModuleDefId::MacroId(_) => (), - } - } - } - items.extend(uses.values()); - items -} - -fn emit_function( - db: &dyn HirDatabase, - trap: &mut TrapFile, - container: Option, - function: ra_ap_hir_def::FunctionId, - name: &ra_ap_hir::Name, -) -> trap::Label { - let sig = db.callable_item_signature(function.into()); - let parameters = collect_generic_parameters(db, function.into(), container); - - assert_eq!(sig.binders.len(Interner), parameters.len()); - let sig = sig.skip_binders(); - let ty_vars = &[parameters]; - let function_data = db.function_data(function); - let mut self_param = None; - let params = sig - .params() - .iter() - .enumerate() - .filter_map(|(idx, p)| { - let type_repr = emit_hir_ty(trap, db, ty_vars, p); - - if idx == 0 && function_data.has_self_param() { - // Check if the self parameter is a reference - let (is_ref, is_mut) = match p.kind(Interner) { - chalk_ir::TyKind::Ref(mutability, _, _) => { - (true, matches!(mutability, chalk_ir::Mutability::Mut)) - } - chalk_ir::TyKind::Raw(mutability, _) => { - (false, matches!(mutability, chalk_ir::Mutability::Mut)) - } - _ => (false, false), - }; - - self_param = Some(trap.emit(generated::SelfParam { - id: trap::TrapId::Star, - attrs: vec![], - type_repr, - is_ref, - is_mut, - lifetime: None, - name: None, - })); - None - } else { - Some(trap.emit(generated::Param { - id: trap::TrapId::Star, - attrs: vec![], - type_repr, - pat: None, - })) - } - }) - .collect(); - - let ret_type = emit_hir_ty(trap, db, ty_vars, sig.ret()); - - let param_list = trap.emit(generated::ParamList { - id: trap::TrapId::Star, - params, - self_param, - }); - let ret_type = ret_type.map(|ret_type| { - trap.emit(generated::RetTypeRepr { - id: trap::TrapId::Star, - type_repr: Some(ret_type), - }) - }); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.as_str().to_owned()), - })); - let data = db.function_data(function); - let visibility = emit_visibility( - db, - trap, - data.visibility - .resolve(db.upcast(), &function.resolver(db.upcast())), - ); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, function.into()); - trap.emit(generated::Function { - id: trap::TrapId::Star, - name, - attrs: vec![], - body: None, - is_const: data.is_const(), - is_default: data.is_default(), - visibility, - abi: None, - is_async: data.is_async(), - is_gen: false, - is_unsafe: data.is_unsafe(), - generic_param_list, - param_list: Some(param_list), - ret_type, - where_clause: None, - }) -} - -fn collect_generic_parameters( - db: &dyn HirDatabase, - def: GenericDefId, - container: Option, -) -> Vec { - let mut parameters = Vec::new(); - let gen_params = db.generic_params(def); - collect(&gen_params, &mut parameters); - if let Some(gen_params) = container.map(|container| db.generic_params(container)) { - collect(gen_params.as_ref(), &mut parameters); - } - return parameters; - - fn collect(gen_params: &GenericParams, parameters: &mut Vec) { - // Self, Lifetimes, TypesOrConsts - let skip = if gen_params.trait_self_param().is_some() { - parameters.push("Self".into()); - 1 - } else { - 0 - }; - parameters.extend(gen_params.iter_lt().map(|(_, lt)| lt.name.as_str().into())); - parameters.extend(gen_params.iter_type_or_consts().skip(skip).map(|(_, p)| { - p.name() - .map(|p| p.as_str().into()) - .unwrap_or("{error}".into()) - })); - } -} - -fn emit_const( - db: &dyn HirDatabase, - trap: &mut TrapFile, - container: Option, - name: &str, - konst: ra_ap_hir_def::ConstId, - visibility: Visibility, -) -> Option> { - let type_ = db.value_ty(konst.into()); - let parameters = collect_generic_parameters(db, konst.into(), container); - assert_eq!( - type_ - .as_ref() - .map_or(0, |type_| type_.binders.len(Interner)), - parameters.len() - ); - let ty_vars = &[parameters]; - let type_repr = type_.and_then(|type_| emit_hir_ty(trap, db, ty_vars, type_.skip_binders())); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let konst = db.const_data(konst); - let visibility = emit_visibility(db, trap, visibility); - Some(trap.emit(generated::Const { - id: trap::TrapId::Star, - name, - attrs: vec![], - body: None, - is_const: true, - is_default: konst.has_body(), - type_repr, - visibility, - })) -} - -fn emit_static( - db: &dyn HirDatabase, - name: &str, - trap: &mut TrapFile, - statik: ra_ap_hir_def::StaticId, - visibility: Visibility, -) -> Option> { - let type_ = db.value_ty(statik.into()); - let parameters = collect_generic_parameters(db, statik.into(), None); - assert_eq!( - type_ - .as_ref() - .map_or(0, |type_| type_.binders.len(Interner)), - parameters.len() - ); - let ty_vars = &[parameters]; - let type_repr = type_.and_then(|type_| emit_hir_ty(trap, db, ty_vars, type_.skip_binders())); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let statik = db.static_data(statik); - let visibility = emit_visibility(db, trap, visibility); - Some( - trap.emit(generated::Static { - id: trap::TrapId::Star, - name, - attrs: vec![], - body: None, - type_repr, - visibility, - is_mut: statik.mutable(), - is_static: true, - is_unsafe: statik.has_unsafe_kw(), - }) - .into(), - ) -} - -fn emit_type_alias( - db: &dyn HirDatabase, - trap: &mut TrapFile, - container: Option, - name: &str, - alias_id: ra_ap_hir_def::TypeAliasId, - visibility: Visibility, -) -> Option> { - let (type_, _) = db.type_for_type_alias_with_diagnostics(alias_id); - let parameters = collect_generic_parameters(db, alias_id.into(), container); - assert_eq!(type_.binders.len(Interner), parameters.len()); - let ty_vars = &[parameters]; - let type_repr = emit_hir_ty(trap, db, ty_vars, type_.skip_binders()); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let visibility = emit_visibility(db, trap, visibility); - let alias = db.type_alias_data(alias_id); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, alias_id.into()); - Some(trap.emit(generated::TypeAlias { - id: trap::TrapId::Star, - name, - attrs: vec![], - is_default: container.is_some() && alias.type_ref.is_some(), - type_repr, - visibility, - generic_param_list, - type_bound_list: None, - where_clause: None, - })) -} - -fn emit_generic_param_list( - trap: &mut TrapFile, - db: &dyn HirDatabase, - ty_vars: &[Vec], - def: GenericDefId, -) -> Option> { - let params = db.generic_params(def); - let trait_self_param = params.trait_self_param(); - if params.is_empty() || params.len() == 1 && trait_self_param.is_some() { - return None; - } - let mut generic_params = Vec::new(); - generic_params.extend(params.iter_lt().map( - |(_, param)| -> trap::Label { - let lifetime = trap - .emit(generated::Lifetime { - id: trap::TrapId::Star, - text: Some(param.name.as_str().to_owned()), - }) - .into(); - - trap.emit(generated::LifetimeParam { - id: trap::TrapId::Star, - attrs: vec![], - lifetime, - type_bound_list: None, - }) - .into() - }, - )); - generic_params.extend( - params - .iter_type_or_consts() - .filter(|(id, _)| trait_self_param != Some(*id)) - .map( - |(param_id, param)| -> trap::Label { - match param { - TypeOrConstParamData::TypeParamData(param) => { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: param.name.as_ref().map(|name| name.as_str().to_owned()), - })); - let resolver = def.resolver(db.upcast()); - let mut ctx = TyLoweringContext::new( - db, - &resolver, - ¶ms.types_map, - def.into(), - ); - - let default_type = param - .default - .and_then(|ty| emit_hir_ty(trap, db, ty_vars, &ctx.lower_ty(ty))); - trap.emit(generated::TypeParam { - id: trap::TrapId::Star, - attrs: vec![], - name, - default_type, - type_bound_list: None, - }) - .into() - } - TypeOrConstParamData::ConstParamData(param) => { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: param.name.as_str().to_owned().into(), - })); - let param_id = TypeOrConstParamId { - parent: def, - local_id: param_id, - }; - let ty = db.const_param_ty(ConstParamId::from_unchecked(param_id)); - let type_repr = emit_hir_ty(trap, db, ty_vars, &ty); - trap.emit(generated::ConstParam { - id: trap::TrapId::Star, - attrs: vec![], - name, - default_val: None, - is_const: true, - type_repr, - }) - .into() - } - } - }, - ), - ); - trap.emit(generated::GenericParamList { - id: trap::TrapId::Star, - generic_params, - }) - .into() -} -fn emit_adt( - db: &dyn HirDatabase, - name: &str, - trap: &mut TrapFile, - adt_id: ra_ap_hir_def::AdtId, - visibility: Visibility, -) -> Option> { - let parameters = collect_generic_parameters(db, adt_id.into(), None); - let ty_vars = &[parameters]; - - match adt_id { - ra_ap_hir_def::AdtId::StructId(struct_id) => { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let field_list = emit_variant_data(trap, db, ty_vars, struct_id.into()).into(); - let visibility = emit_visibility(db, trap, visibility); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, adt_id.into()); - Some( - trap.emit(generated::Struct { - id: trap::TrapId::Star, - name, - attrs: vec![], - field_list, - generic_param_list, - visibility, - where_clause: None, - }) - .into(), - ) - } - ra_ap_hir_def::AdtId::EnumId(enum_id) => { - let data = db.enum_variants(enum_id); - let variants = data - .variants - .iter() - .map(|(enum_id, name)| { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.as_str().to_owned()), - })); - let field_list = emit_variant_data(trap, db, ty_vars, (*enum_id).into()).into(); - let visibility = None; - trap.emit(generated::Variant { - id: trap::TrapId::Star, - name, - field_list, - attrs: vec![], - discriminant: None, - visibility, - }) - }) - .collect(); - let variant_list = Some(trap.emit(generated::VariantList { - id: trap::TrapId::Star, - variants, - })); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let visibility = emit_visibility(db, trap, visibility); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, adt_id.into()); - Some( - trap.emit(generated::Enum { - id: trap::TrapId::Star, - name, - attrs: vec![], - generic_param_list, - variant_list, - visibility, - where_clause: None, - }) - .into(), - ) - } - ra_ap_hir_def::AdtId::UnionId(union_id) => { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let struct_field_list = emit_variant_data(trap, db, ty_vars, union_id.into()).into(); - let visibility = emit_visibility(db, trap, visibility); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, adt_id.into()); - Some( - trap.emit(generated::Union { - id: trap::TrapId::Star, - name, - attrs: vec![], - struct_field_list, - generic_param_list, - visibility, - where_clause: None, - }) - .into(), - ) - } - } -} - -fn emit_trait( - db: &dyn HirDatabase, - name: &str, - trap: &mut TrapFile, - trait_id: ra_ap_hir_def::TraitId, - visibility: Visibility, -) -> Option> { - let parameters = collect_generic_parameters(db, trait_id.into(), None); - let ty_vars = &[parameters]; - let trait_items = db.trait_items(trait_id); - let assoc_items: Vec> = trait_items - .items - .iter() - .flat_map(|(name, item)| match item { - AssocItemId::FunctionId(function_id) => { - Some(emit_function(db, trap, Some(trait_id.into()), *function_id, name).into()) - } - - AssocItemId::ConstId(const_id) => emit_const( - db, - trap, - Some(trait_id.into()), - name.as_str(), - *const_id, - visibility, - ) - .map(Into::into), - AssocItemId::TypeAliasId(type_alias_id) => emit_type_alias( - db, - trap, - Some(trait_id.into()), - name.as_str(), - *type_alias_id, - visibility, - ) - .map(Into::into), - }) - .collect(); - let assoc_item_list = Some(trap.emit(generated::AssocItemList { - id: trap::TrapId::Star, - assoc_items, - attrs: vec![], - })); - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(name.to_owned()), - })); - let visibility = emit_visibility(db, trap, visibility); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, trait_id.into()); - Some( - trap.emit(generated::Trait { - id: trap::TrapId::Star, - name, - assoc_item_list, - attrs: vec![], - generic_param_list, - is_auto: false, - is_unsafe: false, - type_bound_list: None, - visibility, - where_clause: None, - }) - .into(), - ) -} - -fn emit_module_impls( - db: &dyn HirDatabase, - module: &ModuleData, - trap: &mut TrapFile, -) -> Vec> { - let mut items = Vec::new(); - module.scope.impls().for_each(|imp| { - let self_ty = db.impl_self_ty(imp); - let parameters = collect_generic_parameters(db, imp.into(), None); - let parameters_len = parameters.len(); - assert_eq!(self_ty.binders.len(Interner), parameters_len); - - let ty_vars = &[parameters]; - let self_ty = emit_hir_ty(trap, db, ty_vars, self_ty.skip_binders()); - let path = db.impl_trait(imp).map(|trait_ref| { - assert_eq!(trait_ref.binders.len(Interner), parameters_len); - trait_path(db, trap, ty_vars, trait_ref.skip_binders()) - }); - let trait_ = path.map(|path| { - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into() - }); - let imp_items = db.impl_items(imp); - let assoc_items = imp_items - .items - .iter() - .flat_map(|item| { - if let (name, AssocItemId::FunctionId(function)) = item { - Some(emit_function(db, trap, Some(imp.into()), *function, name).into()) - } else { - None - } - }) - .collect(); - let assoc_item_list = Some(trap.emit(generated::AssocItemList { - id: trap::TrapId::Star, - assoc_items, - attrs: vec![], - })); - let generic_param_list = emit_generic_param_list(trap, db, ty_vars, imp.into()); - items.push( - trap.emit(generated::Impl { - id: trap::TrapId::Star, - trait_, - self_ty, - assoc_item_list, - attrs: vec![], - generic_param_list, - is_const: false, - is_default: false, - is_unsafe: false, - visibility: None, - where_clause: None, - }) - .into(), - ); - }); - items -} - -fn emit_visibility( - db: &dyn HirDatabase, - trap: &mut TrapFile, - visibility: Visibility, -) -> Option> { - let path = match visibility { - Visibility::Module(module_id, VisibilityExplicitness::Explicit) => { - Some(make_path_mod(db.upcast(), module_id)) - } - Visibility::Public => Some(vec![]), - Visibility::Module(_, VisibilityExplicitness::Implicit) => None, - }; - path.map(|path| { - let path = make_qualified_path(trap, path, None); - trap.emit(generated::Visibility { - id: trap::TrapId::Star, - path, - }) - }) -} -fn push_ty_vars(ty_vars: &[Vec], vars: Vec) -> Vec> { - let mut result = ty_vars.to_vec(); - result.push(vars); - result -} -fn emit_hir_type_bound( - db: &dyn HirDatabase, - trap: &mut TrapFile, - ty_vars: &[Vec], - type_bound: &Binders>, -) -> Option> { - // Rust-analyzer seems to call `wrap_empty_binders` on `WhereClause`s. - let parameters = vec![]; - assert_eq!(type_bound.binders.len(Interner), parameters.len(),); - let ty_vars = &push_ty_vars(ty_vars, parameters); - - match type_bound.skip_binders() { - WhereClause::Implemented(trait_ref) => { - let path = trait_path(db, trap, ty_vars, trait_ref); - let type_repr = Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into(), - ); - Some(trap.emit(generated::TypeBound { - id: trap::TrapId::Star, - is_async: false, - is_const: false, - lifetime: None, - type_repr, - use_bound_generic_args: None, - })) - } - WhereClause::AliasEq(_) - | WhereClause::LifetimeOutlives(_) - | WhereClause::TypeOutlives(_) => None, // TODO - } -} - -fn trait_path( - db: &dyn HirDatabase, - trap: &mut TrapFile, - ty_vars: &[Vec], - trait_ref: &chalk_ir::TraitRef, -) -> Option> { - let mut path = make_path(db, trait_ref.hir_trait_id()); - path.push( - db.trait_data(trait_ref.hir_trait_id()) - .name - .as_str() - .to_owned(), - ); - let generic_arg_list = emit_generic_arg_list( - trap, - db, - ty_vars, - &trait_ref.substitution.as_slice(Interner)[1..], - ); - - make_qualified_path(trap, path, generic_arg_list) -} - -fn emit_hir_fn_ptr( - trap: &mut TrapFile, - db: &dyn HirDatabase, - ty_vars: &[Vec], - function: &FnPointer, -) -> trap::Label { - // Currently rust-analyzer does not handle `for<'a'> fn()` correctly: - // ```rust - // TyKind::Function(FnPointer { - // num_binders: 0, // FIXME lower `for<'a> fn()` correctly - // ``` - // https://github.com/rust-lang/rust-analyzer/blob/c5882732e6e6e09ac75cddd13545e95860be1c42/crates/hir-ty/src/lower.rs#L325 - let parameters = vec![]; - assert_eq!(function.num_binders, parameters.len(),); - let ty_vars = &push_ty_vars(ty_vars, parameters); - - let parameters: Vec<_> = function.substitution.0.type_parameters(Interner).collect(); - - let (ret_type, params) = parameters.split_last().unwrap(); - - let ret_type = emit_hir_ty(trap, db, ty_vars, ret_type); - let ret_type = Some(trap.emit(generated::RetTypeRepr { - id: trap::TrapId::Star, - type_repr: ret_type, - })); - let params = params - .iter() - .map(|t| { - let type_repr = emit_hir_ty(trap, db, ty_vars, t); - trap.emit(generated::Param { - id: trap::TrapId::Star, - attrs: vec![], - type_repr, - pat: None, - }) - }) - .collect(); - let param_list = Some(trap.emit(generated::ParamList { - id: trap::TrapId::Star, - params, - self_param: None, - })); - let is_unsafe = matches!(function.sig.safety, ra_ap_hir::Safety::Unsafe); - trap.emit(generated::FnPtrTypeRepr { - id: trap::TrapId::Star, - abi: None, - is_async: false, - is_const: false, - is_unsafe, - ret_type, - param_list, - }) -} - -fn scalar_to_str(scalar: &Scalar) -> &'static str { - match scalar { - Scalar::Bool => "bool", - Scalar::Char => "char", - Scalar::Int(IntTy::I8) => "i8", - Scalar::Int(IntTy::I16) => "i16", - Scalar::Int(IntTy::I32) => "i32", - Scalar::Int(IntTy::I64) => "i64", - Scalar::Int(IntTy::I128) => "i128", - Scalar::Int(IntTy::Isize) => "isize", - Scalar::Uint(UintTy::U8) => "u8", - Scalar::Uint(UintTy::U16) => "u16", - Scalar::Uint(UintTy::U32) => "u32", - Scalar::Uint(UintTy::U64) => "u64", - Scalar::Uint(UintTy::U128) => "u128", - Scalar::Uint(UintTy::Usize) => "usize", - Scalar::Float(FloatTy::F16) => "f16", - Scalar::Float(FloatTy::F32) => "f32", - Scalar::Float(FloatTy::F64) => "f64", - Scalar::Float(FloatTy::F128) => "f128", - } -} - -fn make_path(db: &dyn HirDatabase, item: impl HasModule) -> Vec { - let db = db.upcast(); - let module = item.module(db); - make_path_mod(db, module) -} - -fn make_path_mod(db: &dyn DefDatabase, module: ModuleId) -> Vec { - let mut path = Vec::new(); - let mut module = module; - loop { - if module.is_block_module() { - path.push("".to_owned()); - } else if let Some(name) = module.name(db).map(|x| x.as_str().to_owned()).or_else(|| { - module.as_crate_root().and_then(|k| { - let krate = k.krate().extra_data(db); - krate - .display_name - .as_ref() - .map(|x| x.canonical_name().to_string()) - }) - }) { - path.push(name); - } else { - path.push("".to_owned()); - } - if let Some(parent) = module.containing_module(db) { - module = parent; - } else { - break; - } - } - path.reverse(); - path -} - -fn make_qualified_path( - trap: &mut TrapFile, - path: Vec, - generic_arg_list: Option>, -) -> Option> { - fn qualified_path( - trap: &mut TrapFile, - qualifier: Option>, - name: String, - generic_arg_list: Option>, - ) -> trap::Label { - let identifier = Some(trap.emit(generated::NameRef { - id: trap::TrapId::Star, - text: Some(name), - })); - let segment = Some(trap.emit(generated::PathSegment { - id: trap::TrapId::Star, - generic_arg_list, - identifier, - parenthesized_arg_list: None, - ret_type: None, - return_type_syntax: None, - })); - trap.emit(generated::Path { - id: trap::TrapId::Star, - qualifier, - segment, - }) - } - let args = std::iter::repeat_n(None, &path.len() - 1).chain(std::iter::once(generic_arg_list)); - path.into_iter() - .zip(args) - .fold(None, |q, (p, a)| Some(qualified_path(trap, q, p, a))) -} -fn emit_hir_ty( - trap: &mut TrapFile, - db: &dyn HirDatabase, - ty_vars: &[Vec], - ty: &Ty, -) -> Option> { - match ty.kind(ra_ap_hir_ty::Interner) { - chalk_ir::TyKind::Never => Some( - trap.emit(generated::NeverTypeRepr { - id: trap::TrapId::Star, - }) - .into(), - ), - - chalk_ir::TyKind::Placeholder(_index) => Some( - trap.emit(generated::InferTypeRepr { - id: trap::TrapId::Star, - }) - .into(), - ), - - chalk_ir::TyKind::Tuple(_size, substitution) => { - let fields = substitution.type_parameters(ra_ap_hir_ty::Interner); - let fields = fields - .flat_map(|field| emit_hir_ty(trap, db, ty_vars, &field)) - .collect(); - - Some( - trap.emit(generated::TupleTypeRepr { - id: trap::TrapId::Star, - fields, - }) - .into(), - ) - } - chalk_ir::TyKind::Raw(mutability, ty) => { - let type_repr = emit_hir_ty(trap, db, ty_vars, ty); - - Some( - trap.emit(generated::PtrTypeRepr { - id: trap::TrapId::Star, - is_mut: matches!(mutability, chalk_ir::Mutability::Mut), - is_const: false, - type_repr, - }) - .into(), - ) - } - chalk_ir::TyKind::Ref(mutability, lifetime, ty) => { - let type_repr = emit_hir_ty(trap, db, ty_vars, ty); - let lifetime = emit_lifetime(trap, ty_vars, lifetime); - Some( - trap.emit(generated::RefTypeRepr { - id: trap::TrapId::Star, - is_mut: matches!(mutability, chalk_ir::Mutability::Mut), - lifetime: Some(lifetime), - type_repr, - }) - .into(), - ) - } - chalk_ir::TyKind::Array(ty, _konst) => { - let element_type_repr = emit_hir_ty(trap, db, ty_vars, ty); - // TODO: handle array size constant - Some( - trap.emit(generated::ArrayTypeRepr { - id: trap::TrapId::Star, - const_arg: None, - element_type_repr, - }) - .into(), - ) - } - chalk_ir::TyKind::Slice(ty) => { - let type_repr = emit_hir_ty(trap, db, ty_vars, ty); - Some( - trap.emit(generated::SliceTypeRepr { - id: trap::TrapId::Star, - type_repr, - }) - .into(), - ) - } - - chalk_ir::TyKind::Adt(adt_id, substitution) => { - let mut path = make_path(db, adt_id.0); - let name = match adt_id.0 { - ra_ap_hir_def::AdtId::StructId(struct_id) => { - db.struct_data(struct_id).name.as_str().to_owned() - } - ra_ap_hir_def::AdtId::UnionId(union_id) => { - db.union_data(union_id).name.as_str().to_owned() - } - ra_ap_hir_def::AdtId::EnumId(enum_id) => { - db.enum_data(enum_id).name.as_str().to_owned() - } - }; - path.push(name); - let generic_arg_list = - emit_generic_arg_list(trap, db, ty_vars, substitution.as_slice(Interner)); - let path = make_qualified_path(trap, path, generic_arg_list); - Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into(), - ) - } - chalk_ir::TyKind::Scalar(scalar) => { - let path = make_qualified_path(trap, vec![scalar_to_str(scalar).to_owned()], None); - Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into(), - ) - } - chalk_ir::TyKind::Str => { - let path = make_qualified_path(trap, vec!["str".to_owned()], None); - Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into(), - ) - } - chalk_ir::TyKind::Function(fn_pointer) => { - Some(emit_hir_fn_ptr(trap, db, ty_vars, fn_pointer).into()) - } - chalk_ir::TyKind::OpaqueType(_, _) - | chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Opaque(_)) => { - let bounds = ty - .impl_trait_bounds(db) - .iter() - .flatten() - .flat_map(|t| emit_hir_type_bound(db, trap, ty_vars, t)) - .collect(); - let type_bound_list = Some(trap.emit(generated::TypeBoundList { - id: trap::TrapId::Star, - bounds, - })); - Some( - trap.emit(generated::ImplTraitTypeRepr { - id: trap::TrapId::Star, - type_bound_list, - }) - .into(), - ) - } - chalk_ir::TyKind::Dyn(dyn_ty) => { - let parameters = vec!["Self".to_owned()]; - assert_eq!(dyn_ty.bounds.binders.len(Interner), parameters.len(),); - let ty_vars = &push_ty_vars(ty_vars, parameters); - - let bounds = dyn_ty - .bounds - .skip_binders() - .iter(ra_ap_hir_ty::Interner) - .flat_map(|t| emit_hir_type_bound(db, trap, ty_vars, t)) - .collect(); - let type_bound_list = Some(trap.emit(generated::TypeBoundList { - id: trap::TrapId::Star, - bounds, - })); - Some( - trap.emit(generated::DynTraitTypeRepr { - id: trap::TrapId::Star, - type_bound_list, - }) - .into(), - ) - } - chalk_ir::TyKind::FnDef(fn_def_id, parameters) => { - let sig = ra_ap_hir_ty::CallableSig::from_def(db, *fn_def_id, parameters); - Some(emit_hir_fn_ptr(trap, db, ty_vars, &sig.to_fn_ptr()).into()) - } - - chalk_ir::TyKind::Alias(chalk_ir::AliasTy::Projection(ProjectionTy { - associated_ty_id, - substitution, - })) - | chalk_ir::TyKind::AssociatedType(associated_ty_id, substitution) => { - let pt = ProjectionTy { - associated_ty_id: *associated_ty_id, - substitution: substitution.clone(), - }; - - // >::Name<...> - - let qualifier = trap.emit(generated::PathSegment { - id: trap::TrapId::Star, - generic_arg_list: None, - identifier: None, - parenthesized_arg_list: None, - ret_type: None, - return_type_syntax: None, - }); - let self_ty = pt.self_type_parameter(db); - let self_ty = emit_hir_ty(trap, db, ty_vars, &self_ty); - if let Some(self_ty) = self_ty { - generated::PathSegment::emit_type_repr(qualifier, self_ty, &mut trap.writer) - } - let trait_ref = pt.trait_ref(db); - let trait_ref = trait_path(db, trap, ty_vars, &trait_ref); - let trait_ref = trait_ref.map(|path| { - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path: Some(path), - }) - }); - if let Some(trait_ref) = trait_ref { - generated::PathSegment::emit_trait_type_repr(qualifier, trait_ref, &mut trap.writer) - } - let data = db.type_alias_data(from_assoc_type_id(*associated_ty_id)); - - let identifier = Some(trap.emit(generated::NameRef { - id: trap::TrapId::Star, - text: Some(data.name.as_str().to_owned()), - })); - let segment = trap.emit(generated::PathSegment { - id: trap::TrapId::Star, - generic_arg_list: None, - identifier, - parenthesized_arg_list: None, - ret_type: None, - return_type_syntax: None, - }); - let qualifier = trap.emit(generated::Path { - id: trap::TrapId::Star, - qualifier: None, - segment: Some(qualifier), - }); - let path = trap.emit(generated::Path { - id: trap::TrapId::Star, - qualifier: Some(qualifier), - segment: Some(segment), - }); - Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path: Some(path), - }) - .into(), - ) - } - chalk_ir::TyKind::BoundVar(var) => { - let var_ = ty_vars - .get(ty_vars.len() - 1 - var.debruijn.depth() as usize) - .and_then(|ty_vars| ty_vars.get(var.index)); - let path = make_qualified_path( - trap, - vec![ - var_.unwrap_or(&format!("E_{}_{}", var.debruijn.depth(), var.index)) - .clone(), - ], - None, - ); - Some( - trap.emit(generated::PathTypeRepr { - id: trap::TrapId::Star, - path, - }) - .into(), - ) - } - chalk_ir::TyKind::Foreign(_) - | chalk_ir::TyKind::Closure(_, _) - | chalk_ir::TyKind::Coroutine(_, _) - | chalk_ir::TyKind::CoroutineWitness(_, _) - | chalk_ir::TyKind::InferenceVar(_, _) - | chalk_ir::TyKind::Error => { - debug!("Unexpected type {:#?}", ty.kind(ra_ap_hir_ty::Interner)); - None - } - } -} - -fn emit_generic_arg_list( - trap: &mut TrapFile, - db: &dyn HirDatabase, - ty_vars: &[Vec], - args: &[GenericArg], -) -> Option> { - if args.is_empty() { - return None; - } - let generic_args = args - .iter() - .flat_map(|arg| { - if let Some(ty) = arg.ty(Interner) { - let type_repr = emit_hir_ty(trap, db, ty_vars, ty); - Some( - trap.emit(generated::TypeArg { - id: trap::TrapId::Star, - type_repr, - }) - .into(), - ) - } else if let Some(l) = arg.lifetime(Interner) { - let lifetime = emit_lifetime(trap, ty_vars, l); - Some( - trap.emit(generated::LifetimeArg { - id: trap::TrapId::Star, - lifetime: Some(lifetime), - }) - .into(), - ) - } else if arg.constant(Interner).is_some() { - Some( - trap.emit(generated::ConstArg { - id: trap::TrapId::Star, - expr: None, - }) - .into(), - ) - } else { - None - } - }) - .collect(); - - trap.emit(generated::GenericArgList { - id: trap::TrapId::Star, - generic_args, - }) - .into() -} - -fn emit_lifetime( - trap: &mut TrapFile, - ty_vars: &[Vec], - l: &chalk_ir::Lifetime, -) -> trap::Label { - let text = match l.data(Interner) { - chalk_ir::LifetimeData::BoundVar(var) => { - let var_ = ty_vars - .get(ty_vars.len() - 1 - var.debruijn.depth() as usize) - .and_then(|ty_vars| ty_vars.get(var.index)); - - Some(var_.map(|v| v.to_string()).unwrap_or(format!( - "'E_{}_{}", - var.debruijn.depth(), - var.index - ))) - } - chalk_ir::LifetimeData::Static => "'static'".to_owned().into(), - chalk_ir::LifetimeData::InferenceVar(_) - | chalk_ir::LifetimeData::Placeholder(_) - | chalk_ir::LifetimeData::Erased - | chalk_ir::LifetimeData::Phantom(_, _) - | chalk_ir::LifetimeData::Error => None, - }; - trap.emit(generated::Lifetime { - id: trap::TrapId::Star, - text, - }) -} - -enum Variant { - Unit, - Record(trap::Label), - Tuple(trap::Label), -} - -impl From for Option> { - fn from(val: Variant) -> Self { - match val { - Variant::Record(label) => Some(label), - Variant::Unit | Variant::Tuple(_) => None, - } - } -} - -impl From for Option> { - fn from(val: Variant) -> Self { - match val { - Variant::Record(label) => Some(label.into()), - Variant::Tuple(label) => Some(label.into()), - Variant::Unit => None, - } - } -} - -fn emit_variant_data( - trap: &mut TrapFile, - db: &dyn HirDatabase, - ty_vars: &[Vec], - variant_id: VariantId, -) -> Variant { - let parameters_len = ty_vars.last().map_or(0, Vec::len); - let variant = variant_id.variant_data(db.upcast()); - match variant.as_ref() { - VariantData::Record { - fields: field_data, - types_map: _, - } => { - let field_types = db.field_types(variant_id); - let fields = field_types - .iter() - .map(|(field_id, ty)| { - let name = Some(trap.emit(generated::Name { - id: trap::TrapId::Star, - text: Some(field_data[field_id].name.as_str().to_owned()), - })); - assert_eq!(ty.binders.len(Interner), parameters_len); - let type_repr = emit_hir_ty(trap, db, ty_vars, ty.skip_binders()); - let visibility = emit_visibility( - db, - trap, - field_data[field_id] - .visibility - .resolve(db.upcast(), &variant_id.resolver(db.upcast())), - ); - trap.emit(generated::StructField { - id: trap::TrapId::Star, - attrs: vec![], - is_unsafe: field_data[field_id].is_unsafe, - name, - type_repr, - visibility, - default: None, - }) - }) - .collect(); - Variant::Record(trap.emit(generated::StructFieldList { - id: trap::TrapId::Star, - fields, - })) - } - VariantData::Tuple { - fields: field_data, .. - } => { - let field_types = db.field_types(variant_id); - let fields = field_types - .iter() - .map(|(field_id, ty)| { - assert_eq!(ty.binders.len(Interner), parameters_len); - let type_repr = emit_hir_ty(trap, db, ty_vars, ty.skip_binders()); - let visibility = emit_visibility( - db, - trap, - field_data[field_id] - .visibility - .resolve(db.upcast(), &variant_id.resolver(db.upcast())), - ); - - trap.emit(generated::TupleField { - id: trap::TrapId::Star, - attrs: vec![], - type_repr, - visibility, - }) - }) - .collect(); - Variant::Tuple(trap.emit(generated::TupleFieldList { - id: trap::TrapId::Star, - fields, - })) - } - VariantData::Unit => Variant::Unit, - } -} - fn cmp_flag(a: &&CfgAtom, b: &&CfgAtom) -> Ordering { match (a, b) { (CfgAtom::Flag(a), CfgAtom::Flag(b)) => a.as_str().cmp(b.as_str()), diff --git a/rust/extractor/src/generated/.generated.list b/rust/extractor/src/generated/.generated.list index a6ed4103871..cb687e1bff0 100644 --- a/rust/extractor/src/generated/.generated.list +++ b/rust/extractor/src/generated/.generated.list @@ -1,2 +1,2 @@ mod.rs 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7 4bcb9def847469aae9d8649461546b7c21ec97cf6e63d3cf394e339915ce65d7 -top.rs 7d0c7b324631207a5f0f89649634431b6fe6f27610a31be118f0dc90c17314f7 7d0c7b324631207a5f0f89649634431b6fe6f27610a31be118f0dc90c17314f7 +top.rs 7f8a694078bc0cde1ce420544d0cf5b83bb297dd29ee4f9d7bcbb1572f0e815a 7f8a694078bc0cde1ce420544d0cf5b83bb297dd29ee4f9d7bcbb1572f0e815a diff --git a/rust/extractor/src/generated/top.rs b/rust/extractor/src/generated/top.rs index 7b64e755030..6cece591734 100644 --- a/rust/extractor/src/generated/top.rs +++ b/rust/extractor/src/generated/top.rs @@ -154,7 +154,6 @@ pub struct Crate { pub id: trap::TrapId, pub name: Option, pub version: Option, - pub module: Option>, pub cfg_options: Vec, pub named_dependencies: Vec>, } @@ -172,9 +171,6 @@ impl trap::TrapEntry for Crate { if let Some(v) = self.version { out.add_tuple("crate_versions", vec![id.into(), v.into()]); } - if let Some(v) = self.module { - out.add_tuple("crate_modules", vec![id.into(), v.into()]); - } for (i, v) in self.cfg_options.into_iter().enumerate() { out.add_tuple("crate_cfg_options", vec![id.into(), i.into(), v.into()]); } diff --git a/rust/ql/.generated.list b/rust/ql/.generated.list index 051cf9f8937..e14f2fd1e46 100644 --- a/rust/ql/.generated.list +++ b/rust/ql/.generated.list @@ -43,7 +43,7 @@ lib/codeql/rust/elements/ConstArg.qll f37b34417503bbd2f3ce09b3211d8fa71f6a954970 lib/codeql/rust/elements/ConstBlockPat.qll a25f42b84dbeb33e10955735ef53b8bb7e3258522d6d1a9068f19adaf1af89d9 eeb816d2b54db77a1e7bb70e90b68d040a0cd44e9d44455a223311c3615c5e6e lib/codeql/rust/elements/ConstParam.qll 248db1e3abef6943326c42478a15f148f8cdaa25649ef5578064b15924c53351 28babba3aea28a65c3fe3b3db6cb9c86f70d7391e9d6ef9188eb2e4513072f9f lib/codeql/rust/elements/ContinueExpr.qll 9f27c5d5c819ad0ebc5bd10967ba8d33a9dc95b9aae278fcfb1fcf9216bda79c 0dc061445a6b89854fdce92aaf022fdc76b724511a50bb777496ce75c9ecb262 -lib/codeql/rust/elements/Crate.qll 37e8d0daa7bef38cee51008499ee3fd6c19800c48f23983a82b7b36bae250813 95eb88b896fe01d57627c1766daf0fe859f086aed6ca1184e1e16b10c9cdaf37 +lib/codeql/rust/elements/Crate.qll 1426960e6f36195e42ea5ea321405c1a72fccd40cd6c0a33673c321c20302d8d 1571a89f89dab43c5291b71386de7aadf52730755ba10f9d696db9ad2f760aff lib/codeql/rust/elements/DynTraitTypeRepr.qll 5953263ec1e77613170c13b5259b22a71c206a7e08841d2fa1a0b373b4014483 d4380c6cc460687dcd8598df27cad954ef4f508f1117a82460d15d295a7b64ab lib/codeql/rust/elements/Element.qll 0b62d139fef54ed2cf2e2334806aa9bfbc036c9c2085d558f15a42cc3fa84c48 24b999b93df79383ef27ede46e38da752868c88a07fe35fcff5d526684ba7294 lib/codeql/rust/elements/Enum.qll 2f122b042519d55e221fceac72fce24b30d4caf1947b25e9b68ee4a2095deb11 83a47445145e4fda8c3631db602a42dbb7a431f259eddf5c09dccd86f6abdd0e @@ -503,7 +503,7 @@ lib/codeql/rust/elements/internal/generated/ConstArg.qll e2451cac6ee464f5b64883d lib/codeql/rust/elements/internal/generated/ConstBlockPat.qll 7526d83ee9565d74776f42db58b1a2efff6fb324cfc7137f51f2206fee815d79 0ab3c22908ff790e7092e576a5df3837db33c32a7922a513a0f5e495729c1ac5 lib/codeql/rust/elements/internal/generated/ConstParam.qll 310342603959a4d521418caec45b585b97e3a5bf79368769c7150f52596a7266 a5dd92f0b24d7dbdaea2daedba3c8d5f700ec7d3ace81ca368600da2ad610082 lib/codeql/rust/elements/internal/generated/ContinueExpr.qll e2010feb14fb6edeb83a991d9357e50edb770172ddfde2e8670b0d3e68169f28 48d09d661e1443002f6d22b8710e22c9c36d9daa9cde09c6366a61e960d717cb -lib/codeql/rust/elements/internal/generated/Crate.qll d245f24e9da4f180c526a6d092f554a9577bae7225c81c36a391947c0865eeb3 c95dbb32b2ce4d9664be56c95b19fcd01c2d3244385e55151f9b06b07f04ce9b +lib/codeql/rust/elements/internal/generated/Crate.qll 37f3760d7c0c1c3ca809d07daf7215a8eae6053eda05e88ed7db6e07f4db0781 649a3d7cd7ee99f95f8a4d3d3c41ea2fa848ce7d8415ccbac62977dfc9a49d35 lib/codeql/rust/elements/internal/generated/DynTraitTypeRepr.qll a9d540717af1f00dbea1c683fd6b846cddfb2968c7f3e021863276f123337787 1972efb9bca7aae9a9708ca6dcf398e5e8c6d2416a07d525dba1649b80fbe4d1 lib/codeql/rust/elements/internal/generated/Element.qll d56d22c060fa929464f837b1e16475a4a2a2e42d68235a014f7369bcb48431db 0e48426ca72179f675ac29aa49bbaadb8b1d27b08ad5cbc72ec5a005c291848e lib/codeql/rust/elements/internal/generated/Enum.qll 4f4cbc9cd758c20d476bc767b916c62ba434d1750067d0ffb63e0821bb95ec86 3da735d54022add50cec0217bbf8ec4cf29b47f4851ee327628bcdd6454989d0 @@ -578,7 +578,7 @@ lib/codeql/rust/elements/internal/generated/ParamList.qll c808c9d84dd7800573832b lib/codeql/rust/elements/internal/generated/ParenExpr.qll bc0731505bfe88516205ec360582a4222d2681d11342c93e15258590ddee82f2 d4bd6e0c80cf1d63746c88d4bcb3a01d4c75732e5da09e3ebd9437ced227fb60 lib/codeql/rust/elements/internal/generated/ParenPat.qll 4f168ef5d5bb87a903251cc31b2e44a759b099ec69c90af31783fbb15778c940 0e34f94a45a13396fd57d94c245dc64d1adde2ab0e22b56946f7e94c04e297fc lib/codeql/rust/elements/internal/generated/ParenTypeRepr.qll 40ab5c592e7699c621787793743e33988de71ff42ca27599f5ab3ddb70e3f7d8 12c0a6eed2202ee3e892f61da3b3ce77ac3190854cdf3097e8d2be98aa3cb91d -lib/codeql/rust/elements/internal/generated/ParentChild.qll 2f620064351fc0275ee1c13d1d0681ac927a2af81c13fbb3fae9ef86dd08e585 61cf70eb649f241e2fcd5e0ba34df63f3a14f07032811b9ae151721783a0fd20 +lib/codeql/rust/elements/internal/generated/ParentChild.qll e2c6aaaa1735113f160c0e178d682bff8e9ebc627632f73c0dd2d1f4f9d692a8 61cf70eb649f241e2fcd5e0ba34df63f3a14f07032811b9ae151721783a0fd20 lib/codeql/rust/elements/internal/generated/ParenthesizedArgList.qll c5fa328ea60d3a3333d7c7bb3480969c1873166c7ac8ebb9d0afad7a8099d1a8 2dbbb6200d96f7db7dea4a55bdeab8d67b14d39a43e0bd54ada019f7e466f163 lib/codeql/rust/elements/internal/generated/Pat.qll 3605ac062be2f294ee73336e9669027b8b655f4ad55660e1eab35266275154ee 7f9400db2884d336dd1d21df2a8093759c2a110be9bf6482ce8e80ae0fd74ed4 lib/codeql/rust/elements/internal/generated/Path.qll 9b12afb46fc5a9ad3a811b05472621bbecccb900c47504feb7f29d96b28421ca bcacbffc36fb3e0c9b26523b5963af0ffa9fd6b19f00a2a31bdb2316071546bd @@ -593,7 +593,7 @@ lib/codeql/rust/elements/internal/generated/PtrTypeRepr.qll 51d1e9e683fc79dddbff lib/codeql/rust/elements/internal/generated/PureSynthConstructors.qll e5b8e69519012bbaae29dcb82d53f7f7ecce368c0358ec27ef6180b228a0057f e5b8e69519012bbaae29dcb82d53f7f7ecce368c0358ec27ef6180b228a0057f lib/codeql/rust/elements/internal/generated/RangeExpr.qll 23cca03bf43535f33b22a38894f70d669787be4e4f5b8fe5c8f7b964d30e9027 18624cef6c6b679eeace2a98737e472432e0ead354cca02192b4d45330f047c9 lib/codeql/rust/elements/internal/generated/RangePat.qll 80826a6a6868a803aa2372e31c52a03e1811a3f1f2abdb469f91ca0bfdd9ecb6 34ee1e208c1690cba505dff2c588837c0cd91e185e2a87d1fe673191962276a9 -lib/codeql/rust/elements/internal/generated/Raw.qll 96e66877688eafb2f901d2790aa3a0d3176d795732fbcd349c3f950016651fdf 855be30b38dd0886938d51219f90e8ce8c4929e23c0f6697f344d5296fbb07cc +lib/codeql/rust/elements/internal/generated/Raw.qll de98fe8481864e23e1cd67d926ffd2e8bb8a83ed48901263122068f9c29ab372 3bd67fe283aaf24b94a2e3fd8f6e73ae34f61a097817900925d1cdcd3b745ecc lib/codeql/rust/elements/internal/generated/RefExpr.qll 7d995884e3dc1c25fc719f5d7253179344d63650e217e9ff6530285fe7a57f64 f2c3c12551deea4964b66553fb9b6423ee16fec53bd63db4796191aa60dc6c66 lib/codeql/rust/elements/internal/generated/RefPat.qll 456ede39837463ee22a630ec7ab6c8630d3664a8ea206fcc6e4f199e92fa564c 5622062765f32930465ba6b170e986706f159f6070f48adee3c20e24e8df4e05 lib/codeql/rust/elements/internal/generated/RefTypeRepr.qll 3d8c0bd296d33b91a81633f697a43269a6538df06d277262d3990d3f6880ef57 13680f39e89bcd8299c218aba396f3deec804597e6f7cb7d4a7e7c748b6faa77 diff --git a/rust/ql/lib/codeql/rust/elements/Crate.qll b/rust/ql/lib/codeql/rust/elements/Crate.qll index a092591a470..9bcbcba3b63 100644 --- a/rust/ql/lib/codeql/rust/elements/Crate.qll +++ b/rust/ql/lib/codeql/rust/elements/Crate.qll @@ -5,7 +5,6 @@ private import internal.CrateImpl import codeql.rust.elements.Locatable -import codeql.rust.elements.Module import codeql.rust.elements.internal.NamedCrate final class Crate = Impl::Crate; diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Crate.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Crate.qll index f3eac4f7766..644b23f1a1e 100644 --- a/rust/ql/lib/codeql/rust/elements/internal/generated/Crate.qll +++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Crate.qll @@ -7,7 +7,6 @@ private import codeql.rust.elements.internal.generated.Synth private import codeql.rust.elements.internal.generated.Raw import codeql.rust.elements.internal.LocatableImpl::Impl as LocatableImpl -import codeql.rust.elements.Module import codeql.rust.elements.internal.NamedCrate /** @@ -42,18 +41,6 @@ module Generated { */ final predicate hasVersion() { exists(this.getVersion()) } - /** - * Gets the module of this crate, if it exists. - */ - Module getModule() { - result = Synth::convertModuleFromRaw(Synth::convertCrateToRaw(this).(Raw::Crate).getModule()) - } - - /** - * Holds if `getModule()` exists. - */ - final predicate hasModule() { exists(this.getModule()) } - /** * Gets the `index`th cfg option of this crate (0-based). */ diff --git a/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll b/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll index d06c69e1ce8..d50a13ad7a8 100644 --- a/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll +++ b/rust/ql/lib/codeql/rust/elements/internal/generated/Raw.qll @@ -86,11 +86,6 @@ module Raw { */ string getVersion() { crate_versions(this, result) } - /** - * Gets the module of this crate, if it exists. - */ - Module getModule() { crate_modules(this, result) } - /** * Gets the `index`th cfg option of this crate (0-based). */ diff --git a/rust/ql/lib/rust.dbscheme b/rust/ql/lib/rust.dbscheme index 2df29df1bf8..a1005655e9e 100644 --- a/rust/ql/lib/rust.dbscheme +++ b/rust/ql/lib/rust.dbscheme @@ -238,12 +238,6 @@ crate_versions( string version: string ref ); -#keyset[id] -crate_modules( - int id: @crate ref, - int module: @module ref -); - #keyset[id, index] crate_cfg_options( int id: @crate ref, diff --git a/rust/schema/prelude.py b/rust/schema/prelude.py index 5fc4aba2e1a..6d356567d22 100644 --- a/rust/schema/prelude.py +++ b/rust/schema/prelude.py @@ -116,7 +116,6 @@ class ExtractorStep(Element): class Crate(Locatable): name: optional[string] version: optional[string] - module: optional["Module"] cfg_options: list[string] named_dependencies: list["NamedCrate"] | ql.internal