+name = "num_threads"

+version = "0.1.7"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "5c7398b9c8b70908f6371f47ed36737907c87c52af34c268fed0bf0ceb92ead9"

+dependencies = [

+ "libc",

+]

+

+[[package]]

+version = "3.7.1"

+checksum = "a3a7c64d9bf75b1b8d981124c14c179074e8caa7dfe7b6a12e6222ddcd0c8f72"

+version = "3.7.1"

+checksum = "b088fd20b938a875ea00843b6faf48579462630015c3788d397ad6a786663252"

+version = "0.71.0"

+checksum = "c6999d098000b98415939f13158dac78cb3eeeb7b0c073847f3e4b623866e27c"

+version = "0.71.0"

+checksum = "ae9fb312d942817dab10790881f555928c1f6a11a85186e8e573ad4a86c7d3be"

+version = "0.71.0"

+checksum = "766e3990eb1066a06deefc561b5a01b32ca5c9211feea31cbf4ed50611519872"

+version = "0.71.0"

+checksum = "f4afa98eb7889c137d5a3f1cd189089e16da04d1e4837d358a67aa3dab10ffbe"

+version = "0.71.0"

+checksum = "d9234c96ffb0565286790407fb7eb7f55ebf69267de4db382fdec0a17f14b0e2"

+version = "0.71.0"

+checksum = "273d5f72926a58c7eea27aebc898d1d5b32d23d2342f692a94a2cf8746aa4a2f"

+version = "0.5.1"

+checksum = "8dfafd2fa14c6237fa1fc4310f739d02fa915d92977fa069426591f1de046f81"

+ "itoa",

+ "libc",

+ "num_threads",

+ "time-macros",

+name = "time-macros"

+version = "0.2.18"

+source = "registry+https://github.com/rust-lang/crates.io-index"

+checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"

+dependencies = [

+ "num-conv",

+ "time-core",

+]

+

+[[package]]

+ "time",

+ra-salsa = { path = "./crates/ra-salsa", package = "salsa", version = "0.0.0" }

+ra-ap-rustc_lexer = { version = "0.71.0", default-features = false }

+ra-ap-rustc_parse_format = { version = "0.71.0", default-features = false }

+ra-ap-rustc_index = { version = "0.71.0", default-features = false }

+ra-ap-rustc_abi = { version = "0.71.0", default-features = false }

+ra-ap-rustc_pattern_analysis = { version = "0.71.0", default-features = false }

+ "local-time",

+ "std",

+ "time",

+ra-salsa.workspace = true

+use ra_salsa::Durability;

+ /// The dependencies of this crate.

+ ///

+ /// Note that this may contain more dependencies than the crate actually uses.

+ /// A common example is the test crate which is included but only actually is active when

+ /// declared in source via `extern crate test`.

+use ra_salsa::Durability;

+pub use ra_salsa::{self, Cancelled};

+ impl $crate::ra_salsa::InternKey for $name {

+ fn from_intern_id(v: $crate::ra_salsa::InternId) -> Self {

+ fn as_intern_id(&self) -> $crate::ra_salsa::InternId {

+#[ra_salsa::query_group(SourceDatabaseStorage)]

+ #[ra_salsa::input]

+ #[ra_salsa::lru]

+ #[ra_salsa::lru]

+ #[ra_salsa::input]

+ #[ra_salsa::input]

+ #[ra_salsa::transparent]

+#[ra_salsa::query_group(SourceRootDatabaseStorage)]

+ #[ra_salsa::input]

+ #[ra_salsa::input]

+ db.crate_graph()[krate].dependencies.iter().find_map(|dep| {

+ if dep.name.symbol() == name.symbol() {

+ Some(dep.crate_id)

+ } else {

+ None

+ }

+ })

+ name,

+use base_db::{ra_salsa, CrateId, SourceDatabase, Upcast};

+#[ra_salsa::query_group(InternDatabaseStorage)]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+#[ra_salsa::query_group(DefDatabaseStorage)]

+ #[ra_salsa::input]

+ #[ra_salsa::invoke(ItemTree::file_item_tree_query)]

+ #[ra_salsa::invoke(ItemTree::block_item_tree_query)]

+ #[ra_salsa::invoke(DefMap::crate_def_map_query)]

+ #[ra_salsa::invoke(DefMap::block_def_map_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(StructData::struct_data_query)]

+ #[ra_salsa::invoke(StructData::struct_data_with_diagnostics_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(StructData::union_data_query)]

+ #[ra_salsa::invoke(StructData::union_data_with_diagnostics_query)]

+ #[ra_salsa::invoke(EnumData::enum_data_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(EnumVariantData::enum_variant_data_query)]

+ #[ra_salsa::invoke(EnumVariantData::enum_variant_data_with_diagnostics_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(VariantData::variant_data)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(ImplData::impl_data_query)]

+ #[ra_salsa::invoke(ImplData::impl_data_with_diagnostics_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(TraitData::trait_data_query)]

+ #[ra_salsa::invoke(TraitData::trait_data_with_diagnostics_query)]

+ #[ra_salsa::invoke(TraitAliasData::trait_alias_query)]

+ #[ra_salsa::invoke(TypeAliasData::type_alias_data_query)]

+ #[ra_salsa::invoke(FunctionData::fn_data_query)]

+ #[ra_salsa::invoke(ConstData::const_data_query)]

+ #[ra_salsa::invoke(StaticData::static_data_query)]

+ #[ra_salsa::invoke(Macro2Data::macro2_data_query)]

+ #[ra_salsa::invoke(MacroRulesData::macro_rules_data_query)]

+ #[ra_salsa::invoke(ProcMacroData::proc_macro_data_query)]

+ #[ra_salsa::invoke(ExternCrateDeclData::extern_crate_decl_data_query)]

+ #[ra_salsa::invoke(Body::body_with_source_map_query)]

+ #[ra_salsa::lru]

+ #[ra_salsa::invoke(Body::body_query)]

+ #[ra_salsa::invoke(ExprScopes::expr_scopes_query)]

+ #[ra_salsa::invoke(GenericParams::generic_params_query)]

+ #[ra_salsa::invoke(Attrs::fields_attrs_query)]

+ #[ra_salsa::invoke(crate::attr::fields_attrs_source_map)]

+ #[ra_salsa::invoke(AttrsWithOwner::attrs_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(lang_item::lang_attr)]

+ #[ra_salsa::invoke(LangItems::lang_item_query)]

+ #[ra_salsa::invoke(ImportMap::import_map_query)]

+ #[ra_salsa::invoke(visibility::field_visibilities_query)]

+ #[ra_salsa::invoke(visibility::function_visibility_query)]

+ #[ra_salsa::invoke(visibility::const_visibility_query)]

+ #[ra_salsa::invoke(LangItems::crate_lang_items_query)]

+ #[ra_salsa::invoke(crate::lang_item::notable_traits_in_deps)]

+ #[ra_salsa::invoke(crate::lang_item::crate_notable_traits)]

+ ra_salsa::{self, InternValueTrivial},

+pub struct FunctionId(ra_salsa::InternId);

+pub struct StructId(ra_salsa::InternId);

+pub struct UnionId(ra_salsa::InternId);

+pub struct EnumId(ra_salsa::InternId);

+pub struct ConstId(ra_salsa::InternId);

+pub struct StaticId(ra_salsa::InternId);

+pub struct TraitId(ra_salsa::InternId);

+pub struct TraitAliasId(ra_salsa::InternId);

+pub struct TypeAliasId(ra_salsa::InternId);

+pub struct ImplId(ra_salsa::InternId);

+pub struct UseId(ra_salsa::InternId);

+pub struct ExternCrateId(ra_salsa::InternId);

+pub struct ExternBlockId(ra_salsa::InternId);

+pub struct EnumVariantId(ra_salsa::InternId);

+pub struct Macro2Id(ra_salsa::InternId);

+pub struct MacroRulesId(ra_salsa::InternId);

+pub struct ProcMacroId(ra_salsa::InternId);

+pub struct BlockId(ra_salsa::InternId);

+pub struct ConstBlockId(ra_salsa::InternId);

+pub struct InTypeConstId(ra_salsa::InternId);

+ self, AttrOwner, FieldsShape, FileItemTreeId, ImportKind, ItemTree, ItemTreeId,

+ ItemTreeNode, Macro2, MacroCall, MacroRules, Mod, ModItem, ModKind, TreeId,

+ unresolved_extern_crates: Default::default(),

+struct ImportSource {

+ use_tree: Idx<ast::UseTree>,

+ id: UseId,

+ is_prelude: bool,

+ kind: ImportKind,

+ source: ImportSource { use_tree: idx, id, is_prelude, kind },

+ // The dependencies of the current crate, including optional deps like `test`.

+ // We'd like to avoid emitting a diagnostics avalanche when some `extern crate` doesn't

+ // resolve. When we emit diagnostics for unresolved imports, we only do so if the import

+ // doesn't start with an unresolved crate's name.

+ unresolved_extern_crates: FxHashSet<Name>,

+ // Add all

+

+ let res = self.def_map.resolve_path_fp_with_macro(

+ self.db,

+ ResolveMode::Import,

+ module_id,

+ &import.path,

+ BuiltinShadowMode::Module,

+ None, // An import may resolve to any kind of macro.

+ );

+ let def = res.resolved_def;

+ if res.reached_fixedpoint == ReachedFixedPoint::No || def.is_none() {

+ return PartialResolvedImport::Unresolved;

+ }

+ if res.from_differing_crate {

+ return PartialResolvedImport::Resolved(

+ def.filter_visibility(|v| matches!(v, Visibility::Public)),

+ );

+ // Check whether all namespaces are resolved.

+ if def.is_full() {

+ PartialResolvedImport::Resolved(def)

+ PartialResolvedImport::Indeterminate(def)

+ ImportSource {

+ kind: kind @ (ImportKind::Plain | ImportKind::TypeOnly),

+ id,

+ use_tree,

+ ..

+ } => {

+ if kind == ImportKind::TypeOnly {

+ def.values = None;

+ def.macros = None;

+ }

+ let imp = ImportType::Import(ImportId { import: id, idx: use_tree });

+ ImportSource { kind: ImportKind::Glob, id, is_prelude, .. } => {

+ if is_prelude {

+ // Skip #[test]/#[bench]/#[test_case] expansion, which would merely result in more memory usage

+ if expander.is_test() || expander.is_bench() || expander.is_test_case()

+ for import in &self.unresolved_imports {

+ let &ImportDirective {

+ module_id,

+ import:

+ Import {

+ ref path,

+ source: ImportSource { use_tree, id, is_prelude: _, kind: _ },

+ ..

+ },

+ ..

+ } = import;

+ if matches!(

+ (path.segments().first(), &path.kind),

+ (Some(krate), PathKind::Plain | PathKind::Abs) if self.unresolved_extern_crates.contains(krate)

+ ) {

+ continue;

+ let item_tree_id = id.lookup(self.db).id;

+ self.def_map.diagnostics.push(DefDiagnostic::unresolved_import(

+ module_id,

+ item_tree_id,

+ use_tree,

+ ));

+ let is_crate_root =

+ self.module_id == DefMap::ROOT && self.def_collector.def_map.block.is_none();

+ if prelude_module.krate != krate && is_crate_root {

+ def_map.modules[self.module_id].scope.define_extern_crate_decl(id);

+

+ let item_tree::ExternCrate { name, visibility, alias, ast_id } =

+ &self.item_tree[item_tree_id];

+

+ let is_self = *name == sym::self_;

+ let resolved = if is_self {

+ cov_mark::hit!(extern_crate_self_as);

+ Some(def_map.crate_root())

+ } else {

+ self.def_collector

+ .deps

+ .get(name)

+ .map(|dep| CrateRootModuleId { krate: dep.crate_id })

+ };

+

+ let name = match alias {

+ Some(ImportAlias::Alias(name)) => Some(name),

+ Some(ImportAlias::Underscore) => None,

+ None => Some(name),

+ };

+

+ if let Some(resolved) = resolved {

+ let vis = resolve_vis(def_map, &self.item_tree[*visibility]);

+

+ if is_crate_root {

+ // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658

+ if let Some(name) = name {

+ Arc::get_mut(&mut def_map.data)

+ .unwrap()

+ .extern_prelude

+ .insert(name.clone(), (resolved, Some(id)));

+ }

+ // they also allow `#[macro_use]`

+ if !is_self {

+ self.process_macro_use_extern_crate(

+ id,

+ attrs.by_key(&sym::macro_use).attrs(),

+ resolved.krate,

+ );

+ }

+ }

+

+ self.def_collector.update(

+ module_id,

+ &[(

+ name.cloned(),

+ PerNs::types(

+ resolved.into(),

+ vis,

+ Some(ImportOrExternCrate::ExternCrate(id)),

+ ),

+ )],

+ vis,

+ Some(ImportType::ExternCrate(id)),

+ );

+ } else {

+ if let Some(name) = name {

+ self.def_collector.unresolved_extern_crates.insert(name.clone());

+ }

+ self.def_collector.def_map.diagnostics.push(

+ DefDiagnostic::unresolved_extern_crate(

+ module_id,

+ InFile::new(self.file_id(), *ast_id),

+ ),

+ target_crate: CrateId,

+ let Some(paths) = attr.parse_path_comma_token_tree(self.def_collector.db.upcast())

+ else {

+ unresolved_extern_crates: Default::default(),

+ ra_salsa::{self, Durability},

+#[ra_salsa::database(

+ storage: ra_salsa::Storage<TestDB>,

+ events: Mutex<Option<Vec<ra_salsa::Event>>>,

+impl ra_salsa::Database for TestDB {

+ fn salsa_event(&self, event: ra_salsa::Event) {

+ pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<ra_salsa::Event> {

+ ra_salsa::EventKind::WillExecute { database_key } => {

+ pub fn is_test_case(self) -> bool {

+ matches!(self, BuiltinAttrExpander::TestCase)

+ }

+ ra_salsa::Durability, CrateGraph, CrateId, CrateWorkspaceData, FileChange, SourceRoot,

+use base_db::{ra_salsa, CrateId, SourceDatabase};

+#[ra_salsa::query_group(ExpandDatabaseStorage)]

+ #[ra_salsa::input]

+ #[ra_salsa::transparent]

+ #[ra_salsa::lru]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(SpanMap::new)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(crate::span_map::expansion_span_map)]

+ #[ra_salsa::invoke(crate::span_map::real_span_map)]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::transparent]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(crate::hygiene::dump_syntax_contexts)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(TokenExpander::macro_expander)]

+ #[ra_salsa::invoke(DeclarativeMacroExpander::expander)]

+ #[ra_salsa::transparent]

+ use base_db::ra_salsa;

+ opaque = ra_salsa::plumbing::get_query_table::<InternSyntaxContextQuery>(db).get_or_insert(

+ ra_salsa::plumbing::get_query_table::<InternSyntaxContextQuery>(db).get_or_insert(

+ use base_db::ra_salsa::debug::DebugQueryTable;

+use base_db::{ra_salsa::InternValueTrivial, CrateId};

+ // Because `syntax_bridge::prettify_macro_expansion::prettify_macro_expansion()` clones subtree for `syn`,

+ // that means it will be offsetted to the beginning.

+ let span_offset = syn.text_range().start();

+ let ctx = span_map.span_at(dollar_crate.text_range().start() + span_offset).ctx;

+use base_db::{ra_salsa::Cycle, CrateId};

+ ra_salsa::{self, InternValueTrivial},

+#[ra_salsa::query_group(HirDatabaseStorage)]

+ #[ra_salsa::invoke(crate::infer::infer_query)]

+ #[ra_salsa::invoke(crate::mir::mir_body_query)]

+ #[ra_salsa::cycle(crate::mir::mir_body_recover)]

+ #[ra_salsa::invoke(crate::mir::mir_body_for_closure_query)]

+ #[ra_salsa::invoke(crate::mir::monomorphized_mir_body_query)]

+ #[ra_salsa::cycle(crate::mir::monomorphized_mir_body_recover)]

+ #[ra_salsa::invoke(crate::mir::monomorphized_mir_body_for_closure_query)]

+ #[ra_salsa::invoke(crate::mir::borrowck_query)]

+ #[ra_salsa::lru]

+ #[ra_salsa::invoke(crate::consteval::const_eval_query)]

+ #[ra_salsa::cycle(crate::consteval::const_eval_recover)]

+ #[ra_salsa::invoke(crate::consteval::const_eval_static_query)]

+ #[ra_salsa::cycle(crate::consteval::const_eval_static_recover)]

+ #[ra_salsa::invoke(crate::consteval::const_eval_discriminant_variant)]

+ #[ra_salsa::cycle(crate::consteval::const_eval_discriminant_recover)]

+ #[ra_salsa::invoke(crate::method_resolution::lookup_impl_method_query)]

+ #[ra_salsa::invoke(crate::layout::layout_of_adt_query)]

+ #[ra_salsa::cycle(crate::layout::layout_of_adt_recover)]

+ #[ra_salsa::invoke(crate::layout::layout_of_ty_query)]

+ #[ra_salsa::cycle(crate::layout::layout_of_ty_recover)]

+ #[ra_salsa::invoke(crate::layout::target_data_layout_query)]

+ #[ra_salsa::invoke(crate::dyn_compatibility::dyn_compatibility_of_trait_query)]

+ #[ra_salsa::invoke(crate::lower::ty_query)]

+ #[ra_salsa::cycle(crate::lower::ty_recover)]

+ #[ra_salsa::invoke(crate::lower::value_ty_query)]

+ #[ra_salsa::invoke(crate::lower::impl_self_ty_query)]

+ #[ra_salsa::cycle(crate::lower::impl_self_ty_recover)]

+ #[ra_salsa::invoke(crate::lower::const_param_ty_query)]

+ #[ra_salsa::invoke(crate::lower::impl_trait_query)]

+ #[ra_salsa::invoke(crate::lower::field_types_query)]

+ #[ra_salsa::invoke(crate::lower::callable_item_sig)]

+ #[ra_salsa::invoke(crate::lower::return_type_impl_traits)]

+ #[ra_salsa::invoke(crate::lower::type_alias_impl_traits)]

+ #[ra_salsa::invoke(crate::lower::generic_predicates_for_param_query)]

+ #[ra_salsa::cycle(crate::lower::generic_predicates_for_param_recover)]

+ #[ra_salsa::invoke(crate::lower::generic_predicates_query)]

+ #[ra_salsa::invoke(crate::lower::generic_predicates_without_parent_query)]

+ #[ra_salsa::invoke(crate::lower::trait_environment_for_body_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(crate::lower::trait_environment_query)]

+ #[ra_salsa::invoke(crate::lower::generic_defaults_query)]

+ #[ra_salsa::cycle(crate::lower::generic_defaults_recover)]

+ #[ra_salsa::invoke(InherentImpls::inherent_impls_in_crate_query)]

+ #[ra_salsa::invoke(InherentImpls::inherent_impls_in_block_query)]

+ #[ra_salsa::invoke(crate::method_resolution::incoherent_inherent_impl_crates)]

+ #[ra_salsa::invoke(TraitImpls::trait_impls_in_crate_query)]

+ #[ra_salsa::invoke(TraitImpls::trait_impls_in_block_query)]

+ #[ra_salsa::invoke(TraitImpls::trait_impls_in_deps_query)]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::interned]

+ #[ra_salsa::invoke(chalk_db::associated_ty_data_query)]

+ #[ra_salsa::invoke(chalk_db::trait_datum_query)]

+ #[ra_salsa::invoke(chalk_db::adt_datum_query)]

+ #[ra_salsa::invoke(chalk_db::impl_datum_query)]

+ #[ra_salsa::invoke(chalk_db::fn_def_datum_query)]

+ #[ra_salsa::invoke(chalk_db::fn_def_variance_query)]

+ #[ra_salsa::invoke(chalk_db::adt_variance_query)]

+ #[ra_salsa::invoke(chalk_db::associated_ty_value_query)]

+ #[ra_salsa::invoke(crate::traits::normalize_projection_query)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::invoke(crate::traits::trait_solve_query)]

+ #[ra_salsa::invoke(chalk_db::program_clauses_for_chalk_env_query)]

+pub struct InternedTypeOrConstParamId(ra_salsa::InternId);

+pub struct InternedLifetimeParamId(ra_salsa::InternId);

+pub struct InternedConstParamId(ra_salsa::InternId);

+pub struct InternedOpaqueTyId(ra_salsa::InternId);

+pub struct InternedClosureId(ra_salsa::InternId);

+pub struct InternedCoroutineId(ra_salsa::InternId);

+pub struct InternedCallableDefId(ra_salsa::InternId);

+ if !matches!(sig.abi, FnAbi::Rust | FnAbi::RustCall) {

+ write!(f, "fn ")?;

+ f.start_location_link(def.into());

+ CallableDefId::FunctionId(ff) => write!(

+ f,

+ "{}",

+ db.function_data(ff).name.display(f.db.upcast(), f.edition())

+ )?,

+ CallableDefId::EnumVariantId(e) => write!(

+ f,

+ "{}",

+ db.enum_variant_data(e).name.display(f.db.upcast(), f.edition())

+ )?,

+ infer::{coerce::CoerceMany, expr::ExprIsRead, unify::InferenceTable},

+ ExprIsRead::Yes,

+ infer::{coerce::CoerceNever, unify::InferenceTable},

+ Adjustment, Binders, DynTy, InferenceDiagnostic, Interner, PlaceholderIndex,

+ QuantifiedWhereClauses, Ty, TyExt, TyKind, TypeFlags, WhereClause,

+ // We don't want to report errors with unknown types currently.

+ // UnknownCastPtrKind,

+ // UnknownExprPtrKind,

+ if let Ok((adj, _)) = table.coerce(&self.expr_ty, &self.cast_ty, CoerceNever::Yes) {

+ if let Ok((adj, _)) = table.coerce(&self.expr_ty, &fn_ptr, CoerceNever::Yes)

+ {

+ if let Ok((adj, _)) = table.coerce(&self.expr_ty, &array_ptr_type, CoerceNever::Yes)

+ {

+ if table.coerce(ety, t_cast, CoerceNever::Yes).is_ok() {

+ // (_, None) => Err(CastError::UnknownCastPtrKind),

+ // (None, _) => Err(CastError::UnknownExprPtrKind),

+ (_, None) | (None, _) => Ok(()),

+ // None => Err(CastError::UnknownExprPtrKind),

+ None => Ok(()),

+ // None => Err(CastError::UnknownCastPtrKind),

+ None => Ok(()),

+ // None => Err(CastError::UnknownCastPtrKind),

+ None => Ok(()),

+ infer::coerce::CoerceNever,

+ let _ = self.coerce(Some(closure_expr), closure_ty, &expected_ty, CoerceNever::Yes);

+ let result1 = ctx.table.coerce_inner(self.merged_ty(), &target_ty, CoerceNever::Yes);

+ let result2 = ctx.table.coerce_inner(expr_ty.clone(), &target_ty, CoerceNever::Yes);

+ if let Ok(res) = ctx.coerce(expr, &expr_ty, &self.merged_ty(), CoerceNever::Yes) {

+ } else if let Ok(res) = ctx.coerce(expr, &self.merged_ty(), &expr_ty, CoerceNever::Yes) {

+ let (adjustments, ty) = table.coerce(&ty1_with_vars, &ty2_with_vars, CoerceNever::Yes)?;

+#[derive(Clone, Copy, PartialEq, Eq)]

+pub(crate) enum CoerceNever {

+ Yes,

+ No,

+}

+

+ // [Comment from rustc](https://github.com/rust-lang/rust/blob/4cc494bbfe9911d24f3ee521f98d5c6bb7e3ffe8/compiler/rustc_hir_typeck/src/coercion.rs#L85-L89)

+ // Whether we allow `NeverToAny` coercions. This is unsound if we're

+ // coercing a place expression without it counting as a read in the MIR.

+ // This is a side-effect of HIR not really having a great distinction

+ // between places and values.

+ coerce_never: CoerceNever,

+ let (adjustments, ty) = self.table.coerce(&from_ty, &to_ty, coerce_never)?;

+ coerce_never: CoerceNever,

+ match self.coerce_inner(from_ty, &to_ty, coerce_never) {

+ fn coerce_inner(&mut self, from_ty: Ty, to_ty: &Ty, coerce_never: CoerceNever) -> CoerceResult {

+ if coerce_never == CoerceNever::Yes {

+ // Subtle: If we are coercing from `!` to `?T`, where `?T` is an unbound

+ // type variable, we want `?T` to fallback to `!` if not

+ // otherwise constrained. An example where this arises:

+ //

+ // let _: Option<?T> = Some({ return; });

+ //

+ // here, we would coerce from `!` to `?T`.

+ return success(simple(Adjust::NeverToAny)(to_ty.clone()), to_ty.clone(), vec![]);

+ } else {

+ return self.unify_and(&from_ty, to_ty, identity);

+ }

+ Literal, Pat, PatId, Statement, UnaryOp,

+ resolver::ValueNs,

+ coerce::{CoerceMany, CoerceNever, CoercionCause},

+#[derive(Clone, Copy, PartialEq, Eq)]

+pub(crate) enum ExprIsRead {

+ Yes,

+ No,

+}

+

+ pub(crate) fn infer_expr(

+ &mut self,

+ tgt_expr: ExprId,

+ expected: &Expectation,

+ is_read: ExprIsRead,

+ ) -> Ty {

+ let ty = self.infer_expr_inner(tgt_expr, expected, is_read);

+ pub(crate) fn infer_expr_no_expect(&mut self, tgt_expr: ExprId, is_read: ExprIsRead) -> Ty {

+ self.infer_expr_inner(tgt_expr, &Expectation::None, is_read)

+ pub(super) fn infer_expr_coerce(

+ &mut self,

+ expr: ExprId,

+ expected: &Expectation,

+ is_read: ExprIsRead,

+ ) -> Ty {

+ let ty = self.infer_expr_inner(expr, expected, is_read);

+ let coerce_never = if self.expr_guaranteed_to_constitute_read_for_never(expr, is_read) {

+ CoerceNever::Yes

+ } else {

+ CoerceNever::No

+ };

+ match self.coerce(Some(expr), &ty, &target, coerce_never) {

+ /// Whether this expression constitutes a read of value of the type that

+ /// it evaluates to.

+ ///

+ /// This is used to determine if we should consider the block to diverge

+ /// if the expression evaluates to `!`, and if we should insert a `NeverToAny`

+ /// coercion for values of type `!`.

+ ///

+ /// This function generally returns `false` if the expression is a place

+ /// expression and the *parent* expression is the scrutinee of a match or

+ /// the pointee of an `&` addr-of expression, since both of those parent

+ /// expressions take a *place* and not a value.

+ pub(super) fn expr_guaranteed_to_constitute_read_for_never(

+ &mut self,

+ expr: ExprId,

+ is_read: ExprIsRead,

+ ) -> bool {

+ // rustc does the place expr check first, but since we are feeding

+ // readness of the `expr` as a given value, we just can short-circuit

+ // the place expr check if it's true(see codes and comments below)

+ if is_read == ExprIsRead::Yes {

+ return true;

+ }

+

+ // We only care about place exprs. Anything else returns an immediate

+ // which would constitute a read. We don't care about distinguishing

+ // "syntactic" place exprs since if the base of a field projection is

+ // not a place then it would've been UB to read from it anyways since

+ // that constitutes a read.

+ if !self.is_syntactic_place_expr(expr) {

+ return true;

+ }

+

+ // rustc queries parent hir node of `expr` here and determine whether

+ // the current `expr` is read of value per its parent.

+ // But since we don't have hir node, we cannot follow such "bottom-up"

+ // method.

+ // So, we pass down such readness from the parent expression through the

+ // recursive `infer_expr*` calls in a "top-down" manner.

+ is_read == ExprIsRead::Yes

+ }

+

+ /// Whether this pattern constitutes a read of value of the scrutinee that

+ /// it is matching against. This is used to determine whether we should

+ /// perform `NeverToAny` coercions.

+ fn pat_guaranteed_to_constitute_read_for_never(&self, pat: PatId) -> bool {

+ match &self.body[pat] {

+ // Does not constitute a read.

+ Pat::Wild => false,

+

+ // This is unnecessarily restrictive when the pattern that doesn't

+ // constitute a read is unreachable.

+ //

+ // For example `match *never_ptr { value => {}, _ => {} }` or

+ // `match *never_ptr { _ if false => {}, value => {} }`.

+ //

+ // It is however fine to be restrictive here; only returning `true`

+ // can lead to unsoundness.

+ Pat::Or(subpats) => {

+ subpats.iter().all(|pat| self.pat_guaranteed_to_constitute_read_for_never(*pat))

+ }

+

+ // All of these constitute a read, or match on something that isn't `!`,

+ // which would require a `NeverToAny` coercion.

+ Pat::Bind { .. }

+ | Pat::TupleStruct { .. }

+ | Pat::Path(_)

+ | Pat::Tuple { .. }

+ | Pat::Box { .. }

+ | Pat::Ref { .. }

+ | Pat::Lit(_)

+ | Pat::Range { .. }

+ | Pat::Slice { .. }

+ | Pat::ConstBlock(_)

+ | Pat::Record { .. }

+ | Pat::Missing => true,

+ }

+ }

+

+ fn is_syntactic_place_expr(&self, expr: ExprId) -> bool {

+ match &self.body[expr] {

+ // Lang item paths cannot currently be local variables or statics.

+ Expr::Path(Path::LangItem(_, _)) => false,

+ Expr::Path(Path::Normal { type_anchor: Some(_), .. }) => false,

+ Expr::Path(path) => self

+ .resolver

+ .resolve_path_in_value_ns_fully(self.db.upcast(), path)

+ .map_or(true, |res| matches!(res, ValueNs::LocalBinding(_) | ValueNs::StaticId(_))),

+ Expr::Underscore => true,

+ Expr::UnaryOp { op: UnaryOp::Deref, .. } => true,

+ Expr::Field { .. } | Expr::Index { .. } => true,

+ Expr::Call { .. }

+ | Expr::MethodCall { .. }

+ | Expr::Tuple { .. }

+ | Expr::If { .. }

+ | Expr::Match { .. }

+ | Expr::Closure { .. }

+ | Expr::Block { .. }

+ | Expr::Array(..)

+ | Expr::Break { .. }

+ | Expr::Continue { .. }

+ | Expr::Return { .. }

+ | Expr::Become { .. }

+ | Expr::Let { .. }

+ | Expr::Loop { .. }

+ | Expr::InlineAsm(..)

+ | Expr::OffsetOf(..)

+ | Expr::Literal(..)

+ | Expr::Const(..)

+ | Expr::UnaryOp { .. }

+ | Expr::BinaryOp { .. }

+ | Expr::Yield { .. }

+ | Expr::Cast { .. }

+ | Expr::Async { .. }

+ | Expr::Unsafe { .. }

+ | Expr::Await { .. }

+ | Expr::Ref { .. }

+ | Expr::Range { .. }

+ | Expr::Box { .. }

+ | Expr::RecordLit { .. }

+ | Expr::Yeet { .. }

+ | Expr::Missing => false,

+ }

+ }

+

+ fn infer_expr_coerce_never(

+ &mut self,

+ expr: ExprId,

+ expected: &Expectation,

+ is_read: ExprIsRead,

+ ) -> Ty {

+ let ty = self.infer_expr_inner(expr, expected, is_read);

+ self.coerce(Some(expr), &ty, &target, CoerceNever::Yes)

+ fn infer_expr_inner(

+ &mut self,

+ tgt_expr: ExprId,

+ expected: &Expectation,

+ is_read: ExprIsRead,

+ ) -> Ty {

+ ExprIsRead::Yes,

+ let then_ty = self.infer_expr_inner(then_branch, expected, ExprIsRead::Yes);

+ let else_ty = self.infer_expr_inner(else_branch, expected, ExprIsRead::Yes);

+ let child_is_read = if self.pat_guaranteed_to_constitute_read_for_never(pat) {

+ ExprIsRead::Yes

+ } else {

+ ExprIsRead::No

+ };

+ let input_ty = self.infer_expr(expr, &Expectation::none(), child_is_read);

+ this.infer_expr(loc.root, expected, ExprIsRead::Yes)

+ this.infer_expr(

+ body,

+ &Expectation::HasType(TyBuilder::unit()),

+ ExprIsRead::Yes,

+ );

+ let callee_ty = self.infer_expr(*callee, &Expectation::none(), ExprIsRead::Yes);

+ let scrutinee_is_read = arms

+ .iter()

+ .all(|arm| self.pat_guaranteed_to_constitute_read_for_never(arm.pat));

+ let scrutinee_is_read =

+ if scrutinee_is_read { ExprIsRead::Yes } else { ExprIsRead::No };

+ let input_ty = self.infer_expr(*expr, &Expectation::none(), scrutinee_is_read);

+ ExprIsRead::Yes,

+ let arm_ty = self.infer_expr_inner(arm.expr, &expected, ExprIsRead::Yes);

+ self.infer_expr_inner(

+ expr,

+ &Expectation::HasType(opt_coerce_to),

+ ExprIsRead::Yes,

+ )

+ self.infer_expr_coerce(

+ *expr,

+ &Expectation::has_type(yield_ty),

+ ExprIsRead::Yes,

+ );

+ let _ = self.coerce(Some(tgt_expr), &unit, &yield_ty, CoerceNever::Yes);

+ self.infer_expr_no_expect(expr, ExprIsRead::Yes);

+ self.infer_expr_coerce(

+ field.expr,

+ &Expectation::has_type(field_ty),

+ ExprIsRead::Yes,

+ );

+ // Field projections don't constitute reads.

+ self.infer_expr_coerce(field.expr, &Expectation::None, ExprIsRead::No);

+ self.infer_expr(*expr, &Expectation::has_type(ty.clone()), ExprIsRead::Yes);

+ let inner_ty = self.infer_expr_inner(*expr, &Expectation::none(), ExprIsRead::Yes);

+ let expr_ty = self.infer_expr(

+ *expr,

+ &Expectation::Castable(cast_ty.clone()),

+ ExprIsRead::Yes,

+ );

+ let inner_ty = self.infer_expr_inner(*expr, &expectation, ExprIsRead::Yes);

+ let inner_ty = self.infer_expr_inner(*expr, &Expectation::none(), ExprIsRead::Yes);

+ // LHS of assignment doesn't constitute reads.

+ let lhs_ty = self.infer_expr(lhs, &Expectation::none(), ExprIsRead::No);

+ self.infer_expr_coerce(

+ *rhs,

+ &Expectation::has_type(lhs_ty),

+ ExprIsRead::No,

+ );

+ let rhs_ty = self.infer_expr(*rhs, &Expectation::none(), ExprIsRead::Yes);

+ self.infer_expr_coerce(

+ *lhs,

+ &Expectation::HasType(bool_ty.clone()),

+ ExprIsRead::Yes,

+ );

+ self.infer_expr_coerce(

+ *rhs,

+ &Expectation::HasType(bool_ty.clone()),

+ ExprIsRead::Yes,

+ );

+ let lhs_ty =

+ lhs.map(|e| self.infer_expr_inner(e, &Expectation::none(), ExprIsRead::Yes));

+ let rhs_ty = rhs.map(|e| self.infer_expr(e, &rhs_expect, ExprIsRead::Yes));

+ let base_ty = self.infer_expr_inner(*base, &Expectation::none(), ExprIsRead::Yes);

+ let index_ty = self.infer_expr(*index, &Expectation::none(), ExprIsRead::Yes);

+ *ty = self.infer_expr_coerce(

+ *expr,

+ &Expectation::has_type(ty.clone()),

+ ExprIsRead::Yes,

+ );

+ let ty = self.infer_expr_no_expect(expr, ExprIsRead::Yes);

+ _ = self.coerce(Some(expr), &ty, &fnptr_ty, CoerceNever::Yes);

+ _ = self.coerce(Some(expr), &ty, &ptr_ty, CoerceNever::Yes);

+ if self.resolve_ty_shallow(&ty).is_never()

+ && self.expr_guaranteed_to_constitute_read_for_never(tgt_expr, is_read)

+ {

+ match this.coerce(Some(tgt_expr), &ty, &target, CoerceNever::Yes) {

+ let cur_elem_ty = self.infer_expr_inner(expr, &expected, ExprIsRead::Yes);

+ self.infer_expr_coerce(

+ initializer,

+ &Expectation::has_type(elem_ty.clone()),

+ ExprIsRead::Yes,

+ );

+ _ => _ = self.infer_expr(repeat, &Expectation::HasType(usize), ExprIsRead::Yes),

+ let return_expr_ty =

+ self.infer_expr_inner(expr, &Expectation::HasType(ret_ty), ExprIsRead::Yes);

+ self.infer_expr_no_expect(expr, ExprIsRead::Yes);

+ let call_expr_ty = self.infer_expr_inner(

+ expr,

+ &Expectation::HasType(ret_ty.clone()),

+ ExprIsRead::Yes,

+ );

+ self.infer_expr_no_expect(expr, ExprIsRead::Yes);

+ let inner_ty = self.infer_expr_inner(inner_expr, &inner_exp, ExprIsRead::Yes);

+ // LHS of assignment doesn't constitute reads.

+ let lhs_ty = self.infer_expr_inner(lhs, &Expectation::none(), ExprIsRead::No);

+ let ty = match self.coerce(None, &rhs_ty, &lhs_ty, CoerceNever::Yes) {

+ let is_read = if matches!(op, BinaryOp::Assignment { .. }) {

+ ExprIsRead::Yes

+ } else {

+ ExprIsRead::No

+ };

+ let lhs_ty = self.infer_expr(lhs, &lhs_expectation, is_read);

+ self.infer_expr_coerce(rhs, &Expectation::has_type(rhs_ty), ExprIsRead::Yes);

+ self.infer_expr_coerce(rhs, &Expectation::has_type(rhs_ty.clone()), ExprIsRead::Yes);

+ // If we have a subpattern that performs a read, we want to consider this

+ // to diverge for compatibility to support something like `let x: () = *never_ptr;`.

+ let target_is_read =

+ if this.pat_guaranteed_to_constitute_read_for_never(*pat) {

+ ExprIsRead::Yes

+ } else {

+ ExprIsRead::No

+ };

+ this.infer_expr(

+ *expr,

+ &Expectation::has_type(decl_ty.clone()),

+ target_is_read,

+ )

+ target_is_read,

+ ExprIsRead::Yes,

+ this.infer_expr(expr, &Expectation::none(), ExprIsRead::Yes);

+ ExprIsRead::Yes,

+ this.infer_expr_coerce(expr, expected, ExprIsRead::Yes)

+ let coerce_never = if this

+ .expr_guaranteed_to_constitute_read_for_never(expr, ExprIsRead::Yes)

+ {

+ CoerceNever::Yes

+ } else {

+ CoerceNever::No

+ };

+ .coerce(

+ Some(expr),

+ &this.result.standard_types.unit.clone(),

+ &t,

+ coerce_never,

+ )

+ // Field projections don't constitute reads.

+ let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::No);

+ let receiver_ty = self.infer_expr_inner(receiver, &Expectation::none(), ExprIsRead::Yes);

+ let ty = self.infer_expr_inner(arg, &expected, ExprIsRead::Yes);

+

+ // Any expression that produces a value of type `!` must have diverged,

+ // unless it's a place expression that isn't being read from, in which case

+ // diverging would be unsound since we may never actually read the `!`.

+ // e.g. `let _ = *never_ptr;` with `never_ptr: *const !`.

+ let coerce_never =

+ if self.expr_guaranteed_to_constitute_read_for_never(arg, ExprIsRead::Yes) {

+ CoerceNever::Yes

+ } else {

+ CoerceNever::No

+ };

+ if self.coerce(Some(arg), &ty, &coercion_target, coerce_never).is_err()

+ && !arg_count_mismatch

+ {

+ self.infer_expr(args[arg_idx as usize], &expected, ExprIsRead::Yes);

+ infer::{expr::ExprIsRead, Expectation, InferenceContext},

+ lower::lower_to_chalk_mutability,

+ Adjust, Adjustment, AutoBorrow, Interner, OverloadedDeref, TyBuilder, TyKind,

+ self.infer_expr(

+ index,

+ &Expectation::none(),

+ ExprIsRead::Yes,

+ )

+ let mut mutability = mutability;

+ let ty = self.result.type_of_expr.get(*expr);

+ let is_mut_ptr = ty.is_some_and(|ty| {

+ let ty = self.table.resolve_ty_shallow(ty);

+ matches!(

+ ty.kind(Interner),

+ chalk_ir::TyKind::Raw(Mutability::Mut, _)

+ )

+ });

+ if is_mut_ptr {

+ mutability = Mutability::Not;

+ } else if let Some(deref_fn) = self

+ infer::{expr::ExprIsRead, BindingMode, Expectation, InferenceContext, TypeMismatch},

+ self.infer_expr(*expr, &Expectation::has_type(expected.clone()), ExprIsRead::Yes)

+ self.infer_expr(expr, &Expectation::has_type(expected.clone()), ExprIsRead::Yes)

+use base_db::ra_salsa::InternId;

+use base_db::ra_salsa::Cycle;

+use base_db::ra_salsa::Cycle;

+use base_db::ra_salsa::InternValueTrivial;

+use base_db::{ra_salsa::Cycle, CrateId};

+use base_db::ra_salsa::{self, InternKey};

+ chalk_ir::ForeignDefId(ra_salsa::InternKey::as_intern_id(&id))

+ ra_salsa::InternKey::from_intern_id(id.0)

+ chalk_ir::AssocTypeId(ra_salsa::InternKey::as_intern_id(&id))

+ ra_salsa::InternKey::from_intern_id(id.0)

+ let interned_id = ra_salsa::InternKey::from_intern_id(ra_salsa::InternId::from(idx.idx));

+ idx: ra_salsa::InternKey::as_intern_id(&interned_id).as_usize(),

+ let interned_id = ra_salsa::InternKey::from_intern_id(ra_salsa::InternId::from(idx.idx));

+ idx: ra_salsa::InternKey::as_intern_id(&interned_id).as_usize(),

+ chalk_ir::TraitId(ra_salsa::InternKey::as_intern_id(&id))

+ ra_salsa::InternKey::from_intern_id(id.0)

+use base_db::ra_salsa::Cycle;

+use base_db::ra_salsa::Cycle;

+ ra_salsa::{self, Durability},

+#[ra_salsa::database(

+ storage: ra_salsa::Storage<TestDB>,

+ events: Mutex<Option<Vec<ra_salsa::Event>>>,

+impl ra_salsa::Database for TestDB {

+ fn salsa_event(&self, event: ra_salsa::Event) {

+impl ra_salsa::ParallelDatabase for TestDB {

+ fn snapshot(&self) -> ra_salsa::Snapshot<TestDB> {

+ ra_salsa::Snapshot::new(TestDB {

+ pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<ra_salsa::Event> {

+ ra_salsa::EventKind::WillExecute { database_key } => {

+use base_db::ra_salsa::InternKey;

+ !1..4 'Foo': fn Foo({unknown}) -> Foo

+ !1..4 'Foo': fn Foo({unknown}) -> Foo

+

+#[test]

+fn diverging_place_match1() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn not_a_read() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let _: ! = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 21..100 '{ ... } }': !

+ 27..98 'unsafe... }': !

+ 48..49 'x': *const !

+ 62..63 '0': i32

+ 62..68 '0 as _': *const !

+ 82..83 '_': !

+ 89..91 '*x': !

+ 90..91 'x': *const !

+ 27..98: expected !, got ()

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match2() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn not_a_read_implicit() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let _ = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 30..106 '{ ... } }': !

+ 36..104 'unsafe... }': !

+ 57..58 'x': *const !

+ 71..72 '0': i32

+ 71..77 '0 as _': *const !

+ 91..92 '_': !

+ 95..97 '*x': !

+ 96..97 'x': *const !

+ 36..104: expected !, got ()

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match3() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn not_a_read_guide_coercion() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let _: () = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 36..116 '{ ... } }': !

+ 42..114 'unsafe... }': !

+ 63..64 'x': *const !

+ 77..78 '0': i32

+ 77..83 '0 as _': *const !

+ 97..98 '_': ()

+ 105..107 '*x': !

+ 106..107 'x': *const !

+ 42..114: expected !, got ()

+ 105..107: expected (), got !

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match4() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn empty_match() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ match *x { _ => {} };

+ }

+}

+"#,

+ expect![[r#"

+ 22..108 '{ ... } }': !

+ 28..106 'unsafe... }': !

+ 49..50 'x': *const !

+ 63..64 '0': i32

+ 63..69 '0 as _': *const !

+ 79..99 'match ...> {} }': ()

+ 85..87 '*x': !

+ 86..87 'x': *const !

+ 90..91 '_': !

+ 95..97 '{}': ()

+ 28..106: expected !, got ()

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match5() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn field_projection() -> ! {

+ unsafe {

+ let x: *const (!, ()) = 0 as _;

+ let _ = (*x).0;

+ }

+}

+"#,

+ expect![[r#"

+ 27..113 '{ ... } }': !

+ 33..111 'unsafe... }': !

+ 54..55 'x': *const (!, ())

+ 74..75 '0': i32

+ 74..80 '0 as _': *const (!, ())

+ 94..95 '_': !

+ 98..104 '(*x).0': !

+ 99..101 '*x': (!, ())

+ 100..101 'x': *const (!, ())

+ 33..111: expected !, got ()

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match6() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn covered_arm() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let (_ | 1i32) = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 22..107 '{ ... } }': !

+ 28..105 'unsafe... }': !

+ 49..50 'x': *const !

+ 63..64 '0': i32

+ 63..69 '0 as _': *const !

+ 84..85 '_': !

+ 84..92 '_ | 1i32': !

+ 88..92 '1i32': i32

+ 88..92 '1i32': i32

+ 96..98 '*x': !

+ 97..98 'x': *const !

+ 28..105: expected !, got ()

+ 88..92: expected !, got i32

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match7() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn uncovered_arm() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let (1i32 | _) = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 24..109 '{ ... } }': !

+ 30..107 'unsafe... }': !

+ 51..52 'x': *const !

+ 65..66 '0': i32

+ 65..71 '0 as _': *const !

+ 86..90 '1i32': i32

+ 86..90 '1i32': i32

+ 86..94 '1i32 | _': !

+ 93..94 '_': !

+ 98..100 '*x': !

+ 99..100 'x': *const !

+ 30..107: expected !, got ()

+ 86..90: expected !, got i32

+ "#]],

+ )

+}

+

+#[test]

+fn diverging_place_match8() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn coerce_ref_binding() -> ! {

+ unsafe {

+ let x: *const ! = 0 as _;

+ let ref _x: () = *x;

+ }

+}

+"#,

+ expect![[r#"

+ 29..114 '{ ... } }': !

+ 35..112 'unsafe... }': !

+ 56..57 'x': *const !

+ 70..71 '0': i32

+ 70..76 '0 as _': *const !

+ 90..96 'ref _x': &'? ()

+ 103..105 '*x': !

+ 104..105 'x': *const !

+ 103..105: expected (), got !

+ "#]],

+ )

+}

+

+#[test]

+fn never_place_isnt_diverging() {

+ check_infer_with_mismatches(

+ r#"

+//- minicore: sized

+fn make_up_a_pointer<T>() -> *const T {

+ unsafe {

+ let x: *const ! = 0 as _;

+ &raw const *x

+ }

+}

+"#,

+ expect![[r#"

+ 38..116 '{ ... } }': *const T

+ 44..114 'unsafe... }': *const T

+ 65..66 'x': *const !

+ 79..80 '0': i32

+ 79..85 '0 as _': *const !

+ 95..108 '&raw const *x': *const !

+ 106..108 '*x': !

+ 107..108 'x': *const !

+ 95..108: expected *const T, got *const !

+ "#]],

+ )

+}

+ 45..46 'A': fn A<i32>(i32) -> A<i32>

+ 71..72 'A': fn A<i32>(i32) -> A<i32>

+ 68..71 'Foo': fn Foo(usize) -> Foo

+ 105..108 'Foo': fn Foo(usize) -> Foo

+ 137..140 'Foo': fn Foo(usize) -> Foo

+ 70..73 'Foo': fn Foo(usize) -> Foo

+ 60..64 'Self': fn Foo(i64) -> Foo

+ 66..70 'Self': fn Foo<i64>(i64) -> Foo<i64>

+ 123..124 'S': fn S<i32>() -> S<i32>

+ 51..52 'S': fn S(usize) -> S

+ 85..86 'C': fn C(usize) -> C

+ 126..127 'C': fn C(usize) -> C

+ 144..148 'Self': fn S2(isize) -> S2

+ 212..220 'Self::V2': fn V2(u32) -> E

+ 265..266 'B': fn B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>

+ 267..268 'B': fn B<A<i32>>(A<i32>) -> B<A<i32>>

+ 269..270 'A': fn A<i32>(i32) -> A<i32>

+ 278..279 'A': fn A<i32>(*mut i32) -> A<i32>

+ 299..300 'B': fn B<B<A<i32>>>(B<A<i32>>) -> B<B<A<i32>>>

+ 301..302 'B': fn B<A<i32>>(A<i32>) -> B<A<i32>>

+ 81..82 'A': fn A<i32>(i32) -> A<i32>

+ 92..93 'A': fn A<u128>(u128) -> A<u128>

+ 107..111 'Some': fn Some<&'static str>(&'static str) -> Option<&'static str>

+ 122..134 'Option::Some': fn Some<&'static str>(&'static str) -> Option<&'static str>

+ 312..325 'm::Alias::Foo': fn Foo(u8) -> Enum

+ 132..135 'Err': fn Err<(), ()>(()) -> Result<(), ()>

+ 149..151 'Ok': fn Ok<(), ()>(()) -> Result<(), ()>

+ 198..201 'Err': fn Err<(), ()>(()) -> Result<(), ()>

+ 215..217 'Ok': fn Ok<(), ()>(()) -> Result<(), ()>

+ 110..114 'Some': fn Some<bool>(bool) -> Option<bool>

+ 148..152 'Some': fn Some<bool>(bool) -> Option<bool>

+ 295..310 'OtherThing::Two': fn Two<i32>(i32) -> OtherThing<i32>

+ 84..92 'Foo::Bar': fn Bar(i32) -> Foo

+ 356..359 'Box': fn Box<Foo<i32>>(Foo<i32>) -> Box<Foo<i32>>

+ 360..363 'Foo': fn Foo<i32>(i32) -> Foo<i32>

+ 51..52 'S': fn S(i32, u64) -> S

+ 57..58 'S': fn S(fn(u32) -> u64) -> S

+ 223..224 'S': fn S<u16>(u16) -> S<u16>

+ 231..235 'R::A': fn A<(), i32>(()) -> R<(), i32>

+ 241..245 'R::B': fn B<(), i32>(i32) -> R<(), i32>

+ 156..159 'Bar': fn Bar<u8>(u8) -> Bar<u8>

+ 150..162 'Option::Some': fn Some<u32>(u32) -> Option<u32>

+ 228..229 'S': fn S<u32>(u32) -> S<u32>

+ 276..277 'S': fn S<i32>(i32) -> S<i32>

+ 295..296 'S': fn S<i32>(i32) -> S<i32>

+ 1044..1048 'Some': fn Some<u32>(u32) -> Option<u32>

+ 207..213 'Struct': fn Struct(usize) -> Struct

+ 226..239 'Enum::Variant': fn Variant(usize) -> Enum

+ 132..139 'Wrapper': fn Wrapper(u32) -> Wrapper

+ 182..189 'Wrapper': fn Wrapper(u32) -> Wrapper

+ ra_salsa::{

+ ra_salsa::{self, Durability},

+#[ra_salsa::database(

+ storage: ManuallyDrop<ra_salsa::Storage<RootDatabase>>,

+impl ra_salsa::Database for RootDatabase {}

+ let mut db = RootDatabase { storage: ManuallyDrop::new(ra_salsa::Storage::default()) };

+impl ra_salsa::ParallelDatabase for RootDatabase {

+ fn snapshot(&self) -> ra_salsa::Snapshot<RootDatabase> {

+ ra_salsa::Snapshot::new(RootDatabase {

+ storage: ManuallyDrop::new(self.storage.snapshot()),

+ })

+#[ra_salsa::query_group(LineIndexDatabaseStorage)]

+ ra_salsa::{Database, ParallelDatabase, Snapshot},

+use base_db::{ra_salsa::Database, SourceDatabase, SourceRootDatabase};

+ ra_salsa::{self, ParallelDatabase},

+#[ra_salsa::query_group(SymbolsDatabaseStorage)]

+ #[ra_salsa::transparent]

+ #[ra_salsa::input]

+ #[ra_salsa::input]

+impl<DB: ParallelDatabase> Snap<ra_salsa::Snapshot<DB>> {

+impl<DB: ParallelDatabase> Clone for Snap<ra_salsa::Snapshot<DB>> {

+ fn clone(&self) -> Snap<ra_salsa::Snapshot<DB>> {

+ // CastError::UnknownCastPtrKind | CastError::UnknownExprPtrKind => (

+ // DiagnosticCode::RustcHardError("E0641"),

+ // "cannot cast to a pointer of an unknown kind".to_owned(),

+ // ),

+ // #[test]

+ // fn order_dependent_cast_inference() {

+ // check_diagnostics(

+ // r#"

+ // //- minicore: sized

+ // fn main() {

+ // let x = &"hello";

+ // let mut y = 0 as *const _;

+ // //^^^^^^^^^^^^^ error: cannot cast to a pointer of an unknown kind

+ // y = x as *const _;

+ // }

+ // "#,

+ // );

+ // }

+

+ #[test]

+ fn cast_isize_to_infer_pointer() {

+ check_diagnostics(

+ r#"

+//- minicore: coerce_unsized

+struct Foo {}

+

+struct Wrap<'a>(&'a mut Foo);

+

+fn main() {

+ let lparam: isize = 0;

+

+ let _wrap = Wrap(unsafe { &mut *(lparam as *mut _) });

+}

+ "#,

+ );

+ }

+

+ #[test]

+ fn regression_15799() {

+ check_diagnostics(

+ r#"

+//- minicore: deref_mut

+struct WrapPtr(*mut u32);

+

+impl core::ops::Deref for WrapPtr {

+ type Target = *mut u32;

+ fn deref(&self) -> &Self::Target {

+ &self.0

+ }

+}

+

+fn main() {

+ let mut x = 0u32;

+ let wrap = WrapPtr(&mut x);

+ unsafe {

+ **wrap = 6;

+ }

+}

+"#,

+ );

+ }

+ // Fix for forms like `fn foo() -> Result<(), String> {}`

+ } else if let Expr::ReturnExpr(ret_expr) = &expr {

+ // Fix for forms like `fn foo() -> Result<(), String> { return; }`

+ if ret_expr.expr().is_none() {

+ let mut builder = TextEdit::builder();

+ builder

+ .insert(ret_expr.syntax().text_range().end(), format!(" {variant_name}(())"));

+ let source_change = SourceChange::from_text_edit(

+ expr_ptr.file_id.original_file(ctx.sema.db),

+ builder.finish(),

+ );

+ let name = format!("Insert {variant_name}(()) as the return value");

+ acc.push(fix("insert_wrapped_unit", &name, source_change, expr_range));

+ }

+ return Some(());

+ fn test_wrapped_unit_as_return_expr() {

+ check_fix(

+ r#"

+//- minicore: result

+fn foo(b: bool) -> Result<(), String> {

+ if b {

+ return$0;

+ }

+

+ Err("oh dear".to_owned())

+}"#,

+ r#"

+fn foo(b: bool) -> Result<(), String> {

+ if b {

+ return Ok(());

+ }

+

+ Err("oh dear".to_owned())

+}"#,

+ );

+ }

+

+ #[test]

+ base_db::{ra_salsa::Durability, SourceDatabase},

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]

+pub struct CallHierarchyConfig {

+ /// Whether to exclude tests from the call hierarchy

+ pub exclude_tests: bool,

+}

+

+ CallHierarchyConfig { exclude_tests }: CallHierarchyConfig,

+ let def_nav = sema.ancestors_with_macros(name.syntax().clone()).find_map(|node| {

+ // We should return def before check if it is a test, so that we

+ // will not continue to search for outer fn in nested fns

+ def.try_to_nav(sema.db).map(|nav| (def, nav))

+

+ if let Some((def, nav)) = def_nav {

+ if exclude_tests && def.is_test(db) {

+ continue;

+ }

+

+ CallHierarchyConfig { exclude_tests }: CallHierarchyConfig,

+ hir::CallableKind::Function(it) => {

+ if exclude_tests && it.is_test(db) {

+ return None;

+ }

+ it.try_to_nav(db)

+ }

+ if exclude_tests && function.is_test(db) {

+ return None;

+ }

+ exclude_tests: bool,

+ let config = crate::CallHierarchyConfig { exclude_tests };

+

+ let incoming_calls = analysis.incoming_calls(config, item_pos).unwrap().unwrap();

+ let outgoing_calls = analysis.outgoing_calls(config, item_pos).unwrap().unwrap();

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+ false,

+

+ #[test]

+ fn test_call_hierarchy_excluding_tests() {

+ check_hierarchy(

+ false,

+ r#"

+fn main() {

+ f1();

+}

+

+fn f1$0() {

+ f2(); f3();

+}

+

+fn f2() {

+ f1(); f3();

+}

+

+#[test]

+fn f3() {

+ f1(); f2();

+}

+"#,

+ expect!["f1 Function FileId(0) 25..52 28..30"],

+ expect![[r#"

+ main Function FileId(0) 0..23 3..7 : FileId(0):16..18

+ f2 Function FileId(0) 54..81 57..59 : FileId(0):68..70

+ f3 Function FileId(0) 83..118 94..96 : FileId(0):105..107"#]],

+ expect![[r#"

+ f2 Function FileId(0) 54..81 57..59 : FileId(0):39..41

+ f3 Function FileId(0) 83..118 94..96 : FileId(0):45..47"#]],

+ );

+

+ check_hierarchy(

+ true,

+ r#"

+fn main() {

+ f1();

+}

+

+fn f1$0() {

+ f2(); f3();

+}

+

+fn f2() {

+ f1(); f3();

+}

+

+#[test]

+fn f3() {

+ f1(); f2();

+}

+"#,

+ expect!["f1 Function FileId(0) 25..52 28..30"],

+ expect![[r#"

+ main Function FileId(0) 0..23 3..7 : FileId(0):16..18

+ f2 Function FileId(0) 54..81 57..59 : FileId(0):68..70"#]],

+ expect!["f2 Function FileId(0) 54..81 57..59 : FileId(0):39..41"],

+ );

+ }

+fn hl_exit_points(

+ def_token: Option<SyntaxToken>,

+ body: ast::Expr,

+) -> Option<FxHashMap<EditionedFileId, FxHashSet<HighlightedRange>>> {

+ let mut highlights: FxHashMap<EditionedFileId, FxHashSet<_>> = FxHashMap::default();

+

+ let mut push_to_highlights = |file_id, range| {

+ if let Some(FileRange { file_id, range }) = original_frange(sema.db, file_id, range) {

+ let hrange = HighlightedRange { category: ReferenceCategory::empty(), range };

+ highlights.entry(file_id).or_default().insert(hrange);

+ }

+ };

+ if let Some(tok) = def_token {

+ let file_id = sema.hir_file_for(&tok.parent()?);

+ let range = Some(tok.text_range());

+ push_to_highlights(file_id, range);

+ }

+

+ WalkExpandedExprCtx::new(sema).walk(&body, &mut |_, expr| {

+ let file_id = sema.hir_file_for(expr.syntax());

+

+ let range = match &expr {

+ ast::Expr::TryExpr(try_) => try_.question_mark_token().map(|token| token.text_range()),

+ ast::Expr::MethodCallExpr(_) | ast::Expr::CallExpr(_) | ast::Expr::MacroExpr(_)

+ if sema.type_of_expr(&expr).map_or(false, |ty| ty.original.is_never()) =>

+ {

+ Some(expr.syntax().text_range())

+ _ => None,

+ push_to_highlights(file_id, range);

+ });

+ // We should handle `return` separately, because when it is used in a `try` block,

+ // it will exit the outside function instead of the block itself.

+ WalkExpandedExprCtx::new(sema)

+ .with_check_ctx(&WalkExpandedExprCtx::is_async_const_block_or_closure)

+ .walk(&body, &mut |_, expr| {

+ ast::Expr::ReturnExpr(expr) => expr.return_token().map(|token| token.text_range()),

+ let tail = match body {

+ ast::Expr::BlockExpr(b) => b.tail_expr(),

+ e => Some(e),

+ };

+ if let Some(tail) = tail {

+ for_each_tail_expr(&tail, &mut |tail| {

+ let file_id = sema.hir_file_for(tail.syntax());

+ let range = match tail {

+ ast::Expr::BreakExpr(b) => b

+ .break_token()

+ .map_or_else(|| tail.syntax().text_range(), |tok| tok.text_range()),

+ _ => tail.syntax().text_range(),

+ };

+ push_to_highlights(file_id, Some(range));

+ });

+ Some(highlights)

+}

+// If `file_id` is None,

+pub(crate) fn highlight_exit_points(

+ sema: &Semantics<'_, RootDatabase>,

+ token: SyntaxToken,

+) -> FxHashMap<EditionedFileId, Vec<HighlightedRange>> {

+ ast::Fn(fn_) => fn_.body().and_then(|body| hl_exit_points(sema, fn_.fn_token(), body.into())),

+ closure.body().and_then(|body| hl_exit_points(sema, pipe_tok, body))

+ Some(ast::BlockModifier::Async(t)) => hl_exit_points(sema, Some(t), blk.into()),

+ hl_exit_points(sema, Some(t), blk.into())

+ let Some(async_token) = block_expr.async_token() else {

+ };

+

+ // Async blocks act similar to closures. So we want to

+ // highlight their exit points too, but only if we are on

+ // the async token.

+ if async_token == token {

+ let exit_points = hl_exit_points(

+ sema,

+ Some(async_token.clone()),

+ block_expr.clone().into(),

+ );

+ merge_map(&mut res, exit_points);

+

+ hl(sema, Some(async_token), Some(block_expr.into()))

+ fn test_hl_exit_points_of_async_blocks() {

+ check(

+ r#"

+pub fn foo() {

+ let x = async$0 {

+ // ^^^^^

+ 0.await;

+ // ^^^^^

+ 0?;

+ // ^

+ return 0;

+ // ^^^^^^

+ 0

+ // ^

+ };

+}

+"#,

+ );

+ }

+

+ #[test]

+ (async { 0.await }).await$0

+ // ^^^^^

+ }).await;

+

+#[test]

+fn regression_18238() {

+ check(

+ r#"

+macro_rules! foo {

+ ($name:ident) => {

+ pub static $name = Foo::new(|| {

+ $crate;

+ });

+ };

+}

+

+foo!(BAR_$0);

+"#,

+ expect![[r#"

+ *BAR_*

+

+ ```rust

+ test

+ ```

+

+ ```rust

+ pub static BAR_: {error} = Foo::new(||{

+ crate;

+ })

+ ```

+ "#]],

+ );

+}

+ ra_salsa::{self, ParallelDatabase},

+ call_hierarchy::{CallHierarchyConfig, CallItem},

+ db: ra_salsa::Snapshot<RootDatabase>,

+ pub fn incoming_calls(

+ &self,

+ config: CallHierarchyConfig,

+ position: FilePosition,

+ ) -> Cancellable<Option<Vec<CallItem>>> {

+ self.with_db(|db| call_hierarchy::incoming_calls(db, config, position))

+ pub fn outgoing_calls(

+ &self,

+ config: CallHierarchyConfig,

+ position: FilePosition,

+ ) -> Cancellable<Option<Vec<CallItem>>> {

+ self.with_db(|db| call_hierarchy::outgoing_calls(db, config, position))

+ // FIXME: Also make use of the syntax context to determine which site we are at?

+ match self_param.syntax().ancestors().find_map(ast::Impl::cast) {

+ Some(impl_def) => {

+ let type_name = target_type_name(&impl_def)?;

+

+ let mut replacement_text = String::from(new_name);

+ replacement_text.push_str(": ");

+ match (self_param.amp_token(), self_param.mut_token()) {

+ (Some(_), None) => replacement_text.push('&'),

+ (Some(_), Some(_)) => replacement_text.push_str("&mut "),

+ (_, _) => (),

+ };

+ replacement_text.push_str(type_name.as_str());

+ Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))

+ }

+ None => {

+ cov_mark::hit!(rename_self_outside_of_methods);

+ let mut replacement_text = String::from(new_name);

+ replacement_text.push_str(": _");

+ Some(TextEdit::replace(self_param.syntax().text_range(), replacement_text))

+ }

+ }

+ fn test_self_outside_of_methods() {

+ cov_mark::check!(rename_self_outside_of_methods);

+ check(

+ "foo",

+ r#"

+fn f($0self) -> i32 {

+ use self as _;

+ self.i

+}

+"#,

+ r#"

+fn f(foo: _) -> i32 {

+ use self as _;

+ foo.i

+}

+"#,

+ );

+ }

+

+ #[test]

+ base_db::ra_salsa::Durability, symbol_index::SymbolsDatabase, FileRange, FxHashSet,

+ ra_salsa::{

+<pre><code><span class="keyword">extern</span> <span class="keyword">crate</span> <span class="self_keyword crate_root public">self</span> <span class="keyword">as</span> <span class="module crate_root declaration">this</span><span class="semicolon">;</span>

+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">std</span><span class="semicolon">;</span>

+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="unresolved_reference">unresolved</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>

+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">test</span> <span class="keyword">as</span> <span class="module crate_root declaration">opt_in_crate</span><span class="semicolon">;</span>

+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">test</span> <span class="keyword">as</span> <span class="punctuation">_</span><span class="semicolon">;</span>

+<span class="keyword">extern</span> <span class="keyword">crate</span> <span class="module crate_root default_library library">proc_macro</span><span class="semicolon">;</span>

+//- /main.rs crate:main deps:std,alloc,test,proc_macro extern-prelude:std,alloc

+extern crate self as this;

+extern crate unresolved as _;

+extern crate test as opt_in_crate;

+extern crate test as _;

+extern crate proc_macro;

+pub struct A;

+//- /test/lib.rs crate:test

+pub struct T;

+//- /proc_macro/lib.rs crate:proc_macro

+pub struct ProcMacro;

+ T![use] if p.nth_at(1, T![<]) => {

+ rustc_lexer::TokenKind::GuardedStrPrefix if self.edition.at_least_2024() => {

+ }

+ rustc_lexer::TokenKind::GuardedStrPrefix => POUND,

+SOURCE_FILE

+ IMPL

+ IMPL_KW "impl"

+ GENERIC_PARAM_LIST

+ L_ANGLE "<"

+ TYPE_PARAM

+ NAME

+ IDENT "T"

+ COLON ":"

+ WHITESPACE "\n"

+ TYPE_BOUND_LIST

+ ERROR

+ USE_KW "use"

+ WHITESPACE " "

+ MACRO_CALL

+ PATH

+ PATH_SEGMENT

+ NAME_REF

+ IDENT "std"

+ SEMICOLON ";"

+ WHITESPACE "\n"

+error 8: expected R_ANGLE

+error 8: expected type

+error 11: expected `{`

+error 15: expected BANG

+error 15: expected `{`, `[`, `(`

+impl<T:

+use std;

+ .map(|build_file| self.workspace_root().join(build_file))

+name = "ra_salsa"

+ra-salsa-macros = { version = "0.0.0", path = "ra-salsa-macros", package = "salsa-macros" }

+name = "ra_salsa_macros"

+//! Implementation for `[ra_salsa::database]` decorator.

+ <#group_path as ra_salsa::plumbing::QueryGroup>::GroupStorage

+ impl ra_salsa::plumbing::HasQueryGroup<#group_path> for #database_name {

+ fn group_storage_mut(&mut self) -> (&#group_storage, &mut ra_salsa::Runtime) {

+ <#group_path as ra_salsa::plumbing::QueryGroup>::GroupData

+ impl ra_salsa::plumbing::DatabaseStorageTypes for #database_name {

+ <Self as ra_salsa::plumbing::HasQueryGroup<#group_path>>::group_storage(self);

+ <Self as ra_salsa::plumbing::HasQueryGroup<#group_path>>::group_storage(self);

+ <Self as ra_salsa::plumbing::HasQueryGroup<#group_path>>::group_storage(self);

+ <Self as ra_salsa::plumbing::HasQueryGroup<#group_path>>::group_storage(self);

+ impl ra_salsa::plumbing::DatabaseOps for #database_name {

+ fn ops_database(&self) -> &dyn ra_salsa::Database {

+ fn ops_salsa_runtime(&self) -> &ra_salsa::Runtime {

+ fn synthetic_write(&mut self, durability: ra_salsa::Durability) {

+ input: ra_salsa::DatabaseKeyIndex,

+ i => panic!("ra_salsa: invalid group index {}", i)

+ input: ra_salsa::DatabaseKeyIndex,

+ revision: ra_salsa::Revision

+ i => panic!("ra_salsa: invalid group index {}", i)

+ input: ra_salsa::DatabaseKeyIndex,

+ ) -> ra_salsa::plumbing::CycleRecoveryStrategy {

+ i => panic!("ra_salsa: invalid group index {}", i)

+ mut op: &mut dyn FnMut(&dyn ra_salsa::plumbing::QueryStorageMassOps),

+ let runtime = ra_salsa::Database::salsa_runtime(self);

+//! Implementation for `[ra_salsa::query_group]` decorator.

+/// Implementation for `[ra_salsa::query_group]` decorator.

+ return Error::new(span, format!("unknown ra_salsa attribute `{name}`"))

+ "#[ra_salsa::invoke] cannot be set on #[ra_salsa::input] queries",

+ // For `#[ra_salsa::interned]` keys, we create a "lookup key" automatically.

+ ra_salsa::plumbing::get_query_table::<#qt>(db).get((#(#key_names),*))

+ fn #set_with_durability_fn_name(&mut self, #(#key_names: #keys,)* value__: #value, durability__: ra_salsa::Durability);

+ ra_salsa::plumbing::get_query_table_mut::<#qt>(db).set((#(#key_names),*), value__)

+ fn #set_with_durability_fn_name(&mut self, #(#key_names: #keys,)* value__: #value, durability__: ra_salsa::Durability) {

+ fn __shim(db: &mut dyn #trait_name, #(#key_names: #keys,)* value__: #value, durability__: ra_salsa::Durability) {

+ ra_salsa::plumbing::get_query_table_mut::<#qt>(db).set_with_durability((#(#key_names),*), value__, durability__)

+ #fn_name: std::sync::Arc<<#qt as ra_salsa::Query>::Storage>,

+ ra_salsa::Database +

+ ra_salsa::plumbing::HasQueryGroup<#group_struct> +

+ impl ra_salsa::plumbing::QueryGroup for #group_struct

+ DB: ra_salsa::Database,

+ DB: ra_salsa::plumbing::HasQueryGroup<#group_struct>,

+ QueryStorage::Memoized => quote!(ra_salsa::plumbing::MemoizedStorage<Self>),

+ QueryStorage::LruMemoized => quote!(ra_salsa::plumbing::LruMemoizedStorage<Self>),

+ quote!(ra_salsa::plumbing::LruDependencyStorage<Self>)

+ quote!(ra_salsa::plumbing::UnitInputStorage<Self>)

+ QueryStorage::Input => quote!(ra_salsa::plumbing::InputStorage<Self>),

+ QueryStorage::Interned => quote!(ra_salsa::plumbing::InternedStorage<Self>),

+ quote!(ra_salsa::plumbing::LookupInternedStorage<Self, #intern_query_type>)

+ #trait_vis fn in_db(self, db: &#dyn_db) -> ra_salsa::QueryTable<'_, Self>

+ ra_salsa::plumbing::get_query_table::<#qt>(db)

+ /// threads have unwound past the ra_salsa invocation.

+ #trait_vis fn in_db_mut(self, db: &mut #dyn_db) -> ra_salsa::QueryTableMut<'_, Self>

+ ra_salsa::plumbing::get_query_table_mut::<#qt>(db)

+ impl<'d> ra_salsa::QueryDb<'d> for #qt

+ impl ra_salsa::Query for #qt

+ group_storage: &'a <Self as ra_salsa::QueryDb<'_>>::GroupStorage,

+ group_storage: &'a <Self as ra_salsa::QueryDb<'_>>::GroupStorage,

+ const CYCLE_STRATEGY: ra_salsa::plumbing::CycleRecoveryStrategy =

+ ra_salsa::plumbing::CycleRecoveryStrategy::Fallback;

+ fn cycle_fallback(db: &<Self as ra_salsa::QueryDb<'_>>::DynDb, cycle: &ra_salsa::Cycle, #key_pattern: &<Self as ra_salsa::Query>::Key)

+ -> <Self as ra_salsa::Query>::Value {

+ const CYCLE_STRATEGY: ra_salsa::plumbing::CycleRecoveryStrategy =

+ ra_salsa::plumbing::CycleRecoveryStrategy::Panic;

+ impl ra_salsa::plumbing::QueryFunction for #qt

+ fn execute(db: &<Self as ra_salsa::QueryDb<'_>>::DynDb, #key_pattern: <Self as ra_salsa::Query>::Key)

+ -> <Self as ra_salsa::Query>::Value {

+ ra_salsa::plumbing::QueryStorageOps::fmt_index(

+ ra_salsa::plumbing::QueryStorageOps::maybe_changed_after(

+ ra_salsa::plumbing::QueryStorageOps::cycle_recovery_strategy(

+ std::sync::Arc::new(ra_salsa::plumbing::QueryStorageOps::new(group_index)),

+ input: ra_salsa::DatabaseKeyIndex,

+ i => panic!("ra_salsa: impossible query index {}", i),

+ input: ra_salsa::DatabaseKeyIndex,

+ revision: ra_salsa::Revision,

+ i => panic!("ra_salsa: impossible query index {}", i),

+ input: ra_salsa::DatabaseKeyIndex,

+ ) -> ra_salsa::plumbing::CycleRecoveryStrategy {

+ i => panic!("ra_salsa: impossible query index {}", i),

+ _runtime: &ra_salsa::Runtime,

+ mut op: &mut dyn FnMut(&dyn ra_salsa::plumbing::QueryStorageMassOps),

+ path.segments.first().map(|s| s.ident != "ra_salsa").unwrap_or(true) || path.segments.len() != 2

+ let mut ra_salsa = vec![];

+ // Leave non-ra_salsa attributes untouched. These are

+ // attributes that don't start with `ra_salsa::` or don't have

+ // Keep the ra_salsa attributes around.