Rollup of 11 pull requests

compiler/rustc_codegen_gcc/src/lib.rs

@@ -286,7 +286,8 @@ impl CodegenBackend for GccCodegenBackend {
     }
 
     fn provide(&self, providers: &mut Providers) {
-        providers.global_backend_features = |tcx, ()| gcc_util::global_gcc_features(tcx.sess)
+        providers.queries.global_backend_features =
+            |tcx, ()| gcc_util::global_gcc_features(tcx.sess)
     }
 
     fn codegen_crate(&self, tcx: TyCtxt<'_>) -> Box<dyn Any> {

compiler/rustc_codegen_llvm/src/lib.rs

@@ -264,7 +264,7 @@ impl CodegenBackend for LlvmCodegenBackend {
     }
 
     fn provide(&self, providers: &mut Providers) {
-        providers.global_backend_features =
+        providers.queries.global_backend_features =
             |tcx, ()| llvm_util::global_llvm_features(tcx.sess, false)
     }
 

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -474,15 +474,15 @@ fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: LocalDefId)
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
-    providers.reachable_non_generics = reachable_non_generics_provider;
-    providers.is_reachable_non_generic = is_reachable_non_generic_provider_local;
-    providers.exported_non_generic_symbols = exported_non_generic_symbols_provider_local;
-    providers.exported_generic_symbols = exported_generic_symbols_provider_local;
-    providers.upstream_monomorphizations = upstream_monomorphizations_provider;
-    providers.is_unreachable_local_definition = is_unreachable_local_definition_provider;
-    providers.upstream_drop_glue_for = upstream_drop_glue_for_provider;
-    providers.upstream_async_drop_glue_for = upstream_async_drop_glue_for_provider;
-    providers.wasm_import_module_map = wasm_import_module_map;
+    providers.queries.reachable_non_generics = reachable_non_generics_provider;
+    providers.queries.is_reachable_non_generic = is_reachable_non_generic_provider_local;
+    providers.queries.exported_non_generic_symbols = exported_non_generic_symbols_provider_local;
+    providers.queries.exported_generic_symbols = exported_generic_symbols_provider_local;
+    providers.queries.upstream_monomorphizations = upstream_monomorphizations_provider;
+    providers.queries.is_unreachable_local_definition = is_unreachable_local_definition_provider;
+    providers.queries.upstream_drop_glue_for = upstream_drop_glue_for_provider;
+    providers.queries.upstream_async_drop_glue_for = upstream_async_drop_glue_for_provider;
+    providers.queries.wasm_import_module_map = wasm_import_module_map;
     providers.extern_queries.is_reachable_non_generic = is_reachable_non_generic_provider_extern;
     providers.extern_queries.upstream_monomorphizations_for =
         upstream_monomorphizations_for_provider;

compiler/rustc_codegen_ssa/src/lib.rs

@@ -266,9 +266,9 @@ pub enum CodegenErrors {
 
 pub fn provide(providers: &mut Providers) {
     crate::back::symbol_export::provide(providers);
-    crate::base::provide(providers);
-    crate::target_features::provide(providers);
-    crate::codegen_attrs::provide(providers);
+    crate::base::provide(&mut providers.queries);
+    crate::target_features::provide(&mut providers.queries);
+    crate::codegen_attrs::provide(&mut providers.queries);
     providers.queries.global_backend_features = |_tcx: TyCtxt<'_>, ()| vec![];
 }
 

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -833,12 +833,13 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
                 // const-eval of `panic_display` assumes the argument is `&&str`
                 if tcx.is_lang_item(callee, LangItem::PanicDisplay) {
-                    match args[0].node.ty(&self.ccx.body.local_decls, tcx).kind() {
-                        ty::Ref(_, ty, _) if matches!(ty.kind(), ty::Ref(_, ty, _) if ty.is_str()) =>
-                            {}
-                        _ => {
-                            self.check_op(ops::PanicNonStr);
-                        }
+                    if let ty::Ref(_, ty, _) =
+                        args[0].node.ty(&self.ccx.body.local_decls, tcx).kind()
+                        && let ty::Ref(_, ty, _) = ty.kind()
+                        && ty.is_str()
+                    {
+                    } else {
+                        self.check_op(ops::PanicNonStr);
                     }
                     // Allow this call, skip all the checks below.
                     return;

compiler/rustc_const_eval/src/lib.rs

@@ -30,20 +30,20 @@ pub use self::errors::ReportErrorExt;
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 pub fn provide(providers: &mut Providers) {
-    const_eval::provide(providers);
-    providers.tag_for_variant = const_eval::tag_for_variant_provider;
-    providers.eval_to_const_value_raw = const_eval::eval_to_const_value_raw_provider;
-    providers.eval_to_allocation_raw = const_eval::eval_to_allocation_raw_provider;
-    providers.eval_static_initializer = const_eval::eval_static_initializer_provider;
+    const_eval::provide(&mut providers.queries);
+    providers.queries.tag_for_variant = const_eval::tag_for_variant_provider;
+    providers.queries.eval_to_const_value_raw = const_eval::eval_to_const_value_raw_provider;
+    providers.queries.eval_to_allocation_raw = const_eval::eval_to_allocation_raw_provider;
+    providers.queries.eval_static_initializer = const_eval::eval_static_initializer_provider;
     providers.hooks.const_caller_location = util::caller_location::const_caller_location_provider;
-    providers.eval_to_valtree = |tcx, ty::PseudoCanonicalInput { typing_env, value }| {
+    providers.queries.eval_to_valtree = |tcx, ty::PseudoCanonicalInput { typing_env, value }| {
         const_eval::eval_to_valtree(tcx, typing_env, value)
     };
     providers.hooks.try_destructure_mir_constant_for_user_output =
         const_eval::try_destructure_mir_constant_for_user_output;
-    providers.valtree_to_const_val =
+    providers.queries.valtree_to_const_val =
         |tcx, cv| const_eval::valtree_to_const_value(tcx, ty::TypingEnv::fully_monomorphized(), cv);
-    providers.check_validity_requirement = |tcx, (init_kind, param_env_and_ty)| {
+    providers.queries.check_validity_requirement = |tcx, (init_kind, param_env_and_ty)| {
         util::check_validity_requirement(tcx, init_kind, param_env_and_ty)
     };
     providers.hooks.validate_scalar_in_layout =

compiler/rustc_interface/src/passes.rs

@@ -880,36 +880,36 @@ pub fn write_interface<'tcx>(tcx: TyCtxt<'tcx>) {
 
 pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
     let providers = &mut Providers::default();
-    providers.analysis = analysis;
-    providers.hir_crate = rustc_ast_lowering::lower_to_hir;
-    providers.resolver_for_lowering_raw = resolver_for_lowering_raw;
-    providers.stripped_cfg_items = |tcx, _| &tcx.resolutions(()).stripped_cfg_items[..];
-    providers.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
-    providers.early_lint_checks = early_lint_checks;
-    providers.env_var_os = env_var_os;
-    limits::provide(providers);
-    proc_macro_decls::provide(providers);
+    providers.queries.analysis = analysis;
+    providers.queries.hir_crate = rustc_ast_lowering::lower_to_hir;
+    providers.queries.resolver_for_lowering_raw = resolver_for_lowering_raw;
+    providers.queries.stripped_cfg_items = |tcx, _| &tcx.resolutions(()).stripped_cfg_items[..];
+    providers.queries.resolutions = |tcx, ()| tcx.resolver_for_lowering_raw(()).1;
+    providers.queries.early_lint_checks = early_lint_checks;
+    providers.queries.env_var_os = env_var_os;
+    limits::provide(&mut providers.queries);
+    proc_macro_decls::provide(&mut providers.queries);
     rustc_const_eval::provide(providers);
-    rustc_middle::hir::provide(providers);
-    rustc_borrowck::provide(providers);
+    rustc_middle::hir::provide(&mut providers.queries);
+    rustc_borrowck::provide(&mut providers.queries);
     rustc_incremental::provide(providers);
     rustc_mir_build::provide(providers);
     rustc_mir_transform::provide(providers);
     rustc_monomorphize::provide(providers);
-    rustc_privacy::provide(providers);
+    rustc_privacy::provide(&mut providers.queries);
     rustc_query_impl::provide(providers);
-    rustc_resolve::provide(providers);
-    rustc_hir_analysis::provide(providers);
-    rustc_hir_typeck::provide(providers);
-    ty::provide(providers);
-    traits::provide(providers);
-    solve::provide(providers);
-    rustc_passes::provide(providers);
-    rustc_traits::provide(providers);
-    rustc_ty_utils::provide(providers);
+    rustc_resolve::provide(&mut providers.queries);
+    rustc_hir_analysis::provide(&mut providers.queries);
+    rustc_hir_typeck::provide(&mut providers.queries);
+    ty::provide(&mut providers.queries);
+    traits::provide(&mut providers.queries);
+    solve::provide(&mut providers.queries);
+    rustc_passes::provide(&mut providers.queries);
+    rustc_traits::provide(&mut providers.queries);
+    rustc_ty_utils::provide(&mut providers.queries);
     rustc_metadata::provide(providers);
-    rustc_lint::provide(providers);
-    rustc_symbol_mangling::provide(providers);
+    rustc_lint::provide(&mut providers.queries);
+    rustc_symbol_mangling::provide(&mut providers.queries);
     rustc_codegen_ssa::provide(providers);
     *providers
 });

compiler/rustc_lint/src/early/diagnostics/check_cfg.rs

@@ -70,7 +70,7 @@ fn cargo_help_sub(
     // `build_script_build`) to try to figure out if we are building a Cargo build script
 
     let unescaped = &inst(EscapeQuotes::No);
-    if matches!(&sess.opts.crate_name, Some(crate_name) if crate_name == "build_script_build") {
+    if let Some("build_script_build") = sess.opts.crate_name.as_deref() {
         lints::UnexpectedCfgCargoHelp::lint_cfg(unescaped)
     } else {
         lints::UnexpectedCfgCargoHelp::lint_cfg_and_build_rs(unescaped, &inst(EscapeQuotes::Yes))

compiler/rustc_lint/src/transmute.rs

@@ -152,7 +152,9 @@ fn check_int_to_ptr_transmute<'tcx>(
         return;
     };
     // bail-out if the argument is literal 0 as we have other lints for those cases
-    if matches!(arg.kind, hir::ExprKind::Lit(hir::Lit { node: LitKind::Int(v, _), .. }) if v == 0) {
+    if let hir::ExprKind::Lit(hir::Lit { node: LitKind::Int(v, _), .. }) = arg.kind
+        && v == 0
+    {
         return;
     }
     // bail-out if the inner type is a ZST

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -585,6 +585,6 @@ const SYMBOL_OFFSET: u8 = 1;
 const SYMBOL_PREDEFINED: u8 = 2;
 
 pub fn provide(providers: &mut Providers) {
-    encoder::provide(providers);
+    encoder::provide(&mut providers.queries);
     decoder::provide(providers);
 }

compiler/rustc_middle/src/mir/pretty.rs

@@ -1871,13 +1871,16 @@ fn pretty_print_const_value_tcx<'tcx>(
     let u8_type = tcx.types.u8;
     match (ct, ty.kind()) {
         // Byte/string slices, printed as (byte) string literals.
-        (_, ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Str) => {
+        (_, ty::Ref(_, inner_ty, _)) if let ty::Str = inner_ty.kind() => {
             if let Some(data) = ct.try_get_slice_bytes_for_diagnostics(tcx) {
                 fmt.write_str(&format!("{:?}", String::from_utf8_lossy(data)))?;
                 return Ok(());
             }
         }
-        (_, ty::Ref(_, inner_ty, _)) if matches!(inner_ty.kind(), ty::Slice(t) if *t == u8_type) => {
+        (_, ty::Ref(_, inner_ty, _))
+            if let ty::Slice(t) = inner_ty.kind()
+                && *t == u8_type =>
+        {
             if let Some(data) = ct.try_get_slice_bytes_for_diagnostics(tcx) {
                 pretty_print_byte_str(fmt, data)?;
                 return Ok(());

compiler/rustc_middle/src/util/mod.rs

@@ -6,20 +6,3 @@ pub struct Providers {
     pub extern_queries: crate::query::ExternProviders,
     pub hooks: crate::hooks::Providers,
 }
-
-/// Backwards compatibility hack to keep the diff small. This
-/// gives direct access to the `queries` field's fields, which
-/// are what almost everything wants access to.
-impl std::ops::DerefMut for Providers {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        &mut self.queries
-    }
-}
-
-impl std::ops::Deref for Providers {
-    type Target = crate::query::Providers;
-
-    fn deref(&self) -> &Self::Target {
-        &self.queries
-    }
-}

compiler/rustc_mir_build/src/lib.rs

@@ -23,12 +23,12 @@ use rustc_middle::util::Providers;
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 pub fn provide(providers: &mut Providers) {
-    providers.check_match = thir::pattern::check_match;
-    providers.lit_to_const = thir::constant::lit_to_const;
-    providers.closure_saved_names_of_captured_variables =
+    providers.queries.check_match = thir::pattern::check_match;
+    providers.queries.lit_to_const = thir::constant::lit_to_const;
+    providers.queries.closure_saved_names_of_captured_variables =
         builder::closure_saved_names_of_captured_variables;
-    providers.check_unsafety = check_unsafety::check_unsafety;
-    providers.check_tail_calls = check_tail_calls::check_tail_calls;
-    providers.thir_body = thir::cx::thir_body;
+    providers.queries.check_unsafety = check_unsafety::check_unsafety;
+    providers.queries.check_tail_calls = check_tail_calls::check_tail_calls;
+    providers.queries.thir_body = thir::cx::thir_body;
     providers.hooks.build_mir_inner_impl = builder::build_mir_inner_impl;
 }

compiler/rustc_mir_transform/src/lib.rs

@@ -206,9 +206,9 @@ rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
 
 pub fn provide(providers: &mut Providers) {
     coverage::query::provide(providers);
-    ffi_unwind_calls::provide(providers);
-    shim::provide(providers);
-    cross_crate_inline::provide(providers);
+    ffi_unwind_calls::provide(&mut providers.queries);
+    shim::provide(&mut providers.queries);
+    cross_crate_inline::provide(&mut providers.queries);
     providers.queries = query::Providers {
         mir_keys,
         mir_built,

compiler/rustc_monomorphize/src/collector.rs

@@ -1825,5 +1825,5 @@ pub(crate) fn collect_crate_mono_items<'tcx>(
 
 pub(crate) fn provide(providers: &mut Providers) {
     providers.hooks.should_codegen_locally = should_codegen_locally;
-    providers.items_of_instance = items_of_instance;
+    providers.queries.items_of_instance = items_of_instance;
 }

compiler/rustc_monomorphize/src/lib.rs

@@ -52,5 +52,5 @@ fn custom_coerce_unsize_info<'tcx>(
 
 pub fn provide(providers: &mut Providers) {
     partitioning::provide(providers);
-    mono_checks::provide(providers);
+    mono_checks::provide(&mut providers.queries);
 }

compiler/rustc_monomorphize/src/partitioning.rs

@@ -1313,20 +1313,20 @@ fn dump_mono_items_stats<'tcx>(
 }
 
 pub(crate) fn provide(providers: &mut Providers) {
-    providers.collect_and_partition_mono_items = collect_and_partition_mono_items;
+    providers.queries.collect_and_partition_mono_items = collect_and_partition_mono_items;
 
-    providers.is_codegened_item =
+    providers.queries.is_codegened_item =
         |tcx, def_id| tcx.collect_and_partition_mono_items(()).all_mono_items.contains(&def_id);
 
-    providers.codegen_unit = |tcx, name| {
+    providers.queries.codegen_unit = |tcx, name| {
         tcx.collect_and_partition_mono_items(())
             .codegen_units
             .iter()
             .find(|cgu| cgu.name() == name)
             .unwrap_or_else(|| panic!("failed to find cgu with name {name:?}"))
     };
 
-    providers.size_estimate = |tcx, instance| {
+    providers.queries.size_estimate = |tcx, instance| {
         match instance.def {
             // "Normal" functions size estimate: the number of
             // statements, plus one for the terminator.

compiler/rustc_parse/src/parser/diagnostics.rs

@@ -761,7 +761,9 @@ impl<'a> Parser<'a> {
         }
 
         // Check for misspelled keywords if there are no suggestions added to the diagnostic.
-        if matches!(&err.suggestions, Suggestions::Enabled(list) if list.is_empty()) {
+        if let Suggestions::Enabled(list) = &err.suggestions
+            && list.is_empty()
+        {
             self.check_for_misspelled_kw(&mut err, &expected);
         }
         Err(err)

compiler/rustc_parse/src/parser/mod.rs

@@ -1203,10 +1203,9 @@ impl<'a> Parser<'a> {
         let mut token = Token::dummy();
         while i < dist {
             token = cursor.next().0;
-            if matches!(
-                token.kind,
-                token::OpenInvisible(origin) | token::CloseInvisible(origin) if origin.skip()
-            ) {
+            if let token::OpenInvisible(origin) | token::CloseInvisible(origin) = token.kind
+                && origin.skip()
+            {
                 continue;
             }
             i += 1;

compiler/rustc_passes/src/lib.rs

@@ -9,7 +9,7 @@
 #![feature(map_try_insert)]
 // tidy-alphabetical-end
 
-use rustc_middle::util::Providers;
+use rustc_middle::query::Providers;
 
 pub mod abi_test;
 mod check_attr;