Remove unused/unnecessary features

compiler/rustc_ast/src/lib.rs

@@ -13,13 +13,11 @@
 #![feature(rustdoc_internals)]
 #![feature(associated_type_bounds)]
 #![feature(box_patterns)]
-#![feature(const_trait_impl)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(min_specialization)]
 #![feature(negative_impls)]
 #![feature(stmt_expr_attributes)]
-#![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 

compiler/rustc_ast_lowering/src/lib.rs

@@ -33,10 +33,8 @@
 #![allow(internal_features)]
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
-#![feature(if_let_guard)]
 #![feature(box_patterns)]
 #![feature(let_chains)]
-#![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 

compiler/rustc_ast_passes/src/lib.rs

@@ -11,7 +11,6 @@
 #![feature(if_let_guard)]
 #![feature(iter_is_partitioned)]
 #![feature(let_chains)]
-#![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 

compiler/rustc_ast_pretty/src/lib.rs

@@ -4,8 +4,6 @@
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 #![feature(box_patterns)]
-#![feature(let_chains)]
-#![recursion_limit = "256"]
 
 mod helpers;
 pub mod pp;

compiler/rustc_attr/src/builtin.rs

@@ -671,9 +671,7 @@ pub fn eval_condition(
                     !eval_condition(mis[0].meta_item().unwrap(), sess, features, eval)
                 }
                 sym::target => {
-                    if let Some(features) = features
-                        && !features.cfg_target_compact
-                    {
+                    if let Some(&Features { cfg_target_compact: false, .. }) = features {
                         feature_err(
                             sess,
                             sym::cfg_target_compact,

compiler/rustc_attr/src/lib.rs

@@ -7,7 +7,6 @@
 #![allow(internal_features)]
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
-#![feature(let_chains)]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 

compiler/rustc_borrowck/src/lib.rs

@@ -8,12 +8,8 @@
 #![feature(let_chains)]
 #![feature(min_specialization)]
 #![feature(never_type)]
-#![feature(lazy_cell)]
 #![feature(rustc_attrs)]
 #![feature(stmt_expr_attributes)]
-#![feature(trusted_step)]
-#![feature(try_blocks)]
-#![recursion_limit = "256"]
 
 #[macro_use]
 extern crate rustc_middle;

compiler/rustc_borrowck/src/nll.rs

@@ -243,16 +243,18 @@ pub(super) fn dump_mir_results<'tcx>(
     });
 
     // Also dump the inference graph constraints as a graphviz file.
-    let _: io::Result<()> = try {
-        let mut file = create_dump_file(infcx.tcx, "regioncx.all.dot", false, "nll", &0, body)?;
-        regioncx.dump_graphviz_raw_constraints(&mut file)?;
-    };
+    let _: io::Result<()> = (|| {
+        let mut file =
+            create_dump_file(infcx.tcx, "regioncx.all.dot", false, "nll", &0 as _, body)?;
+        regioncx.dump_graphviz_raw_constraints(&mut file)
+    })();
 
     // Also dump the inference graph constraints as a graphviz file.
-    let _: io::Result<()> = try {
-        let mut file = create_dump_file(infcx.tcx, "regioncx.scc.dot", false, "nll", &0, body)?;
-        regioncx.dump_graphviz_scc_constraints(&mut file)?;
-    };
+    let _: io::Result<()> = (|| {
+        let mut file =
+            create_dump_file(infcx.tcx, "regioncx.scc.dot", false, "nll", &0 as _, body)?;
+        regioncx.dump_graphviz_scc_constraints(&mut file)
+    })();
 }
 
 #[allow(rustc::diagnostic_outside_of_impl)]

compiler/rustc_builtin_macros/src/lib.rs

@@ -5,16 +5,13 @@
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
-#![feature(array_windows)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(if_let_guard)]
-#![feature(is_sorted)]
 #![feature(let_chains)]
 #![feature(lint_reasons)]
 #![feature(proc_macro_internals)]
 #![feature(proc_macro_quote)]
-#![recursion_limit = "256"]
 
 extern crate proc_macro;
 

compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs

@@ -222,7 +222,7 @@ fn encode_mappings_for_function(
     function_coverage: &FunctionCoverage<'_>,
 ) -> Vec<u8> {
     let counter_regions = function_coverage.counter_regions();
-    if counter_regions.is_empty() {
+    if counter_regions.len() == 0 {
         return Vec::new();
     }
 

compiler/rustc_codegen_llvm/src/lib.rs

@@ -8,15 +8,12 @@
 #![feature(rustdoc_internals)]
 #![doc(rust_logo)]
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
-#![feature(exact_size_is_empty)]
 #![feature(extern_types)]
 #![feature(hash_raw_entry)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
 #![feature(min_specialization)]
-#![feature(never_type)]
 #![feature(impl_trait_in_assoc_type)]
-#![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -685,18 +685,19 @@ impl<'a> Linker for GccLinker<'a> {
 
         if self.sess.target.is_like_osx {
             // Write a plain, newline-separated list of symbols
-            let res: io::Result<()> = try {
+            let res: io::Result<()> = (|| {
                 let mut f = BufWriter::new(File::create(&path)?);
                 for sym in symbols {
                     debug!("  _{sym}");
                     writeln!(f, "_{sym}")?;
                 }
-            };
+                Ok(())
+            })();
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
         } else if is_windows {
-            let res: io::Result<()> = try {
+            let res: io::Result<()> = (|| {
                 let mut f = BufWriter::new(File::create(&path)?);
 
                 // .def file similar to MSVC one but without LIBRARY section
@@ -706,13 +707,14 @@ impl<'a> Linker for GccLinker<'a> {
                     debug!("  _{symbol}");
                     writeln!(f, "  {symbol}")?;
                 }
-            };
+                Ok(())
+            })();
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
             }
         } else {
             // Write an LD version script
-            let res: io::Result<()> = try {
+            let res: io::Result<()> = (|| {
                 let mut f = BufWriter::new(File::create(&path)?);
                 writeln!(f, "{{")?;
                 if !symbols.is_empty() {
@@ -722,8 +724,8 @@ impl<'a> Linker for GccLinker<'a> {
                         writeln!(f, "    {sym};")?;
                     }
                 }
-                writeln!(f, "\n  local:\n    *;\n}};")?;
-            };
+                writeln!(f, "\n  local:\n    *;\n}};")
+            })();
             if let Err(error) = res {
                 self.sess.dcx().emit_fatal(errors::VersionScriptWriteFailure { error });
             }
@@ -992,7 +994,7 @@ impl<'a> Linker for MsvcLinker<'a> {
         }
 
         let path = tmpdir.join("lib.def");
-        let res: io::Result<()> = try {
+        let res: io::Result<()> = (|| {
             let mut f = BufWriter::new(File::create(&path)?);
 
             // Start off with the standard module name header and then go
@@ -1003,7 +1005,8 @@ impl<'a> Linker for MsvcLinker<'a> {
                 debug!("  _{symbol}");
                 writeln!(f, "  {symbol}")?;
             }
-        };
+            Ok(())
+        })();
         if let Err(error) = res {
             self.sess.dcx().emit_fatal(errors::LibDefWriteFailure { error });
         }
@@ -1679,14 +1682,15 @@ impl<'a> Linker for AixLinker<'a> {
 
     fn export_symbols(&mut self, tmpdir: &Path, _crate_type: CrateType, symbols: &[String]) {
         let path = tmpdir.join("list.exp");
-        let res: io::Result<()> = try {
+        let res: io::Result<()> = (|| {
             let mut f = BufWriter::new(File::create(&path)?);
             // FIXME: use llvm-nm to generate export list.
             for symbol in symbols {
                 debug!("  _{symbol}");
                 writeln!(f, "  {symbol}")?;
             }
-        };
+            Ok(())
+        })();
         if let Err(e) = res {
             self.sess.dcx().fatal(format!("failed to write export file: {e}"));
         }
@@ -1988,12 +1992,13 @@ impl<'a> Linker for BpfLinker<'a> {
 
     fn export_symbols(&mut self, tmpdir: &Path, _crate_type: CrateType, symbols: &[String]) {
         let path = tmpdir.join("symbols");
-        let res: io::Result<()> = try {
+        let res: io::Result<()> = (|| {
             let mut f = BufWriter::new(File::create(&path)?);
             for sym in symbols {
                 writeln!(f, "{sym}")?;
             }
-        };
+            Ok(())
+        })();
         if let Err(error) = res {
             self.sess.dcx().emit_fatal(errors::SymbolFileWriteFailure { error });
         } else {

compiler/rustc_codegen_ssa/src/lib.rs

@@ -7,10 +7,7 @@
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
-#![feature(never_type)]
 #![feature(strict_provenance)]
-#![feature(try_blocks)]
-#![recursion_limit = "256"]
 
 //! This crate contains codegen code that is used by all codegen backends (LLVM and others).
 //! The backend-agnostic functions of this crate use functions defined in various traits that

compiler/rustc_const_eval/src/lib.rs

@@ -11,20 +11,13 @@ Rust MIR: a lowered representation of Rust.
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
-#![feature(exact_size_is_empty)]
 #![feature(let_chains)]
-#![feature(map_try_insert)]
-#![feature(min_specialization)]
 #![feature(slice_ptr_get)]
-#![feature(option_get_or_insert_default)]
 #![feature(never_type)]
 #![feature(trait_alias)]
-#![feature(trusted_len)]
-#![feature(trusted_step)]
 #![feature(try_blocks)]
 #![feature(yeet_expr)]
 #![feature(if_let_guard)]
-#![recursion_limit = "256"]
 
 #[macro_use]
 extern crate tracing;

compiler/rustc_data_structures/src/lib.rs

@@ -18,7 +18,6 @@
 #![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(auto_traits)]
-#![feature(cell_leak)]
 #![feature(cfg_match)]
 #![feature(core_intrinsics)]
 #![feature(extend_one)]

compiler/rustc_driver_impl/src/lib.rs

@@ -9,11 +9,8 @@
 #![feature(rustdoc_internals)]
 #![allow(internal_features)]
 #![feature(decl_macro)]
-#![feature(lazy_cell)]
 #![feature(let_chains)]
 #![feature(panic_update_hook)]
-#![feature(result_flattening)]
-#![recursion_limit = "256"]
 #![deny(rustc::untranslatable_diagnostic)]
 #![deny(rustc::diagnostic_outside_of_impl)]
 
@@ -1249,7 +1246,7 @@ pub fn catch_fatal_errors<F: FnOnce() -> R, R>(f: F) -> Result<R, ErrorGuarantee
 /// Variant of `catch_fatal_errors` for the `interface::Result` return type
 /// that also computes the exit code.
 pub fn catch_with_exit_code(f: impl FnOnce() -> interface::Result<()>) -> i32 {
-    match catch_fatal_errors(f).flatten() {
+    match catch_fatal_errors(f).and_then(std::convert::identity) {
         Ok(()) => EXIT_SUCCESS,
         Err(_) => EXIT_FAILURE,
     }

compiler/rustc_error_messages/src/lib.rs

@@ -1,6 +1,5 @@
 #![doc(rust_logo)]
 #![feature(rustdoc_internals)]
-#![feature(let_chains)]
 #![feature(lazy_cell)]
 #![feature(rustc_attrs)]
 #![feature(type_alias_impl_trait)]

compiler/rustc_errors/src/lib.rs

@@ -8,15 +8,12 @@
 #![feature(array_windows)]
 #![feature(associated_type_defaults)]
 #![feature(box_into_inner)]
+#![feature(box_patterns)]
 #![feature(extract_if)]
-#![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
 #![feature(never_type)]
 #![feature(rustc_attrs)]
-#![feature(yeet_expr)]
-#![feature(try_blocks)]
-#![feature(box_patterns)]
 #![feature(error_reporter)]
 #![allow(incomplete_features)]
 #![allow(internal_features)]