remove now not required _

Author: Shourya742

src/bootstrap/src/core/config/config.rs

@@ -554,105 +554,105 @@ impl Config {
         } = toml.install.unwrap_or_default();
 
         let Rust {
-            optimize: rust_optimize_,
+            optimize: rust_optimize,
             debug: rust_debug,
-            codegen_units: rust_codegen_units_,
-            codegen_units_std: rust_codegen_units_std_,
+            codegen_units: rust_codegen_units,
+            codegen_units_std: rust_codegen_units_std,
             rustc_debug_assertions: rust_rustc_debug_assertions,
             std_debug_assertions: rust_std_debug_assertions,
             tools_debug_assertions: rust_tools_debug_assertions,
-            overflow_checks: rust_overflow_checks_,
-            overflow_checks_std: rust_overflow_checks_std_,
-            debug_logging: rust_debug_logging_,
+            overflow_checks: rust_overflow_checks,
+            overflow_checks_std: rust_overflow_checks_std,
+            debug_logging: rust_debug_logging,
             debuginfo_level: rust_debuginfo_level,
-            debuginfo_level_rustc: rust_debuginfo_level_rustc_,
-            debuginfo_level_std: rust_debuginfo_level_std_,
-            debuginfo_level_tools: rust_debuginfo_level_tools_,
-            debuginfo_level_tests: rust_debuginfo_level_tests_,
+            debuginfo_level_rustc: rust_debuginfo_level_rustc,
+            debuginfo_level_std: rust_debuginfo_level_std,
+            debuginfo_level_tools: rust_debuginfo_level_tools,
+            debuginfo_level_tests: rust_debuginfo_level_tests,
             backtrace: rust_backtrace,
             incremental: rust_incremental,
-            randomize_layout: rust_randomize_layout_,
+            randomize_layout: rust_randomize_layout,
             default_linker: rust_default_linker,
             channel: rust_channel,
             musl_root: rust_musl_root,
-            rpath: rust_rpath_,
+            rpath: rust_rpath,
             verbose_tests: rust_verbose_tests,
-            optimize_tests: rust_optimize_tests_,
+            optimize_tests: rust_optimize_tests,
             codegen_tests: rust_codegen_tests,
             omit_git_hash: rust_omit_git_hash,
-            dist_src: rust_dist_src_,
+            dist_src: rust_dist_src,
             save_toolstates: rust_save_toolstates,
-            codegen_backends: rust_codegen_backends_,
+            codegen_backends: rust_codegen_backends,
             lld: rust_lld_enabled,
             llvm_tools: rust_llvm_tools,
             llvm_bitcode_linker: rust_llvm_bitcode_linker,
             deny_warnings: rust_deny_warnings,
             backtrace_on_ice: rust_backtrace_on_ice,
-            verify_llvm_ir: rust_verify_llvm_ir_,
-            thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit_,
-            remap_debuginfo: rust_remap_debuginfo_,
+            verify_llvm_ir: rust_verify_llvm_ir,
+            thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit,
+            remap_debuginfo: rust_remap_debuginfo,
             jemalloc: rust_jemalloc,
             test_compare_mode: rust_test_compare_mode,
             llvm_libunwind: rust_llvm_libunwind,
             control_flow_guard: rust_control_flow_guard,
             ehcont_guard: rust_ehcont_guard,
-            new_symbol_mangling: rust_new_symbol_mangling_,
-            profile_generate: rust_profile_generate_,
-            profile_use: rust_profile_use_,
+            new_symbol_mangling: rust_new_symbol_mangling,
+            profile_generate: rust_profile_generate,
+            profile_use: rust_profile_use,
             download_rustc: rust_download_rustc,
-            lto: rust_lto_,
-            validate_mir_opts: rust_validate_mir_opts_,
-            frame_pointers: rust_frame_pointers_,
-            stack_protector: rust_stack_protector_,
-            strip: rust_strip_,
+            lto: rust_lto,
+            validate_mir_opts: rust_validate_mir_opts,
+            frame_pointers: rust_frame_pointers,
+            stack_protector: rust_stack_protector,
+            strip: rust_strip,
             lld_mode: rust_lld_mode,
-            std_features: rust_std_features_,
+            std_features: rust_std_features,
         } = toml.rust.unwrap_or_default();
 
         let Llvm {
-            optimize: llvm_optimize_,
-            thin_lto: llvm_thin_lto_,
-            release_debuginfo: llvm_release_debuginfo_,
+            optimize: llvm_optimize,
+            thin_lto: llvm_thin_lto,
+            release_debuginfo: llvm_release_debuginfo,
             assertions: llvm_assertions_,
-            tests: llvm_tests_,
-            enzyme: llvm_enzyme_,
+            tests: llvm_tests,
+            enzyme: llvm_enzyme,
             plugins: llvm_plugin,
             static_libstdcpp: llvm_static_libstdcpp,
-            libzstd: llvm_libzstd_,
+            libzstd: llvm_libzstd,
             ninja: llvm_ninja,
-            targets: llvm_targets_,
-            experimental_targets: llvm_experimental_targets_,
-            link_jobs: llvm_link_jobs_,
+            targets: llvm_targets,
+            experimental_targets: llvm_experimental_targets,
+            link_jobs: llvm_link_jobs,
             link_shared: llvm_link_shared_,
-            version_suffix: llvm_version_suffix_,
-            clang_cl: llvm_clang_cl_,
-            cflags: llvm_cflags_,
-            cxxflags: llvm_cxxflags_,
-            ldflags: llvm_ldflags_,
-            use_libcxx: llvm_use_libcxx_,
-            use_linker: llvm_use_linker_,
-            allow_old_toolchain: llvm_allow_old_toolchain_,
-            offload: llvm_offload_,
-            polly: llvm_polly_,
-            clang: llvm_clang_,
-            enable_warnings: llvm_enable_warnings_,
+            version_suffix: llvm_version_suffix,
+            clang_cl: llvm_clang_cl,
+            cflags: llvm_cflags,
+            cxxflags: llvm_cxxflags,
+            ldflags: llvm_ldflags,
+            use_libcxx: llvm_use_libcxx,
+            use_linker: llvm_use_linker,
+            allow_old_toolchain: llvm_allow_old_toolchain,
+            offload: llvm_offload,
+            polly: llvm_polly,
+            clang: llvm_clang,
+            enable_warnings: llvm_enable_warnings,
             download_ci_llvm: llvm_download_ci_llvm,
-            build_config: llvm_build_config_,
+            build_config: llvm_build_config,
         } = toml.llvm.unwrap_or_default();
 
         let Dist {
-            sign_folder: dist_sign_folder_,
-            upload_addr: dist_upload_addr_,
-            src_tarball: dist_src_tarball_,
-            compression_formats: dist_compression_formats_,
-            compression_profile: dist_compression_profile_,
-            include_mingw_linker: dist_include_mingw_linker_,
-            vendor: dist_vendor_,
+            sign_folder: dist_sign_folder,
+            upload_addr: dist_upload_addr,
+            src_tarball: dist_src_tarball,
+            compression_formats: dist_compression_formats,
+            compression_profile: dist_compression_profile,
+            include_mingw_linker: dist_include_mingw_linker,
+            vendor: dist_vendor,
         } = toml.dist.unwrap_or_default();
 
         let Gcc { download_ci_gcc: gcc_download_ci_gcc } = toml.gcc.unwrap_or_default();
 
-        if rust_optimize_.as_ref().is_some_and(|v| matches!(v, RustOptimize::Bool(false))) {
+        if rust_optimize.as_ref().is_some_and(|v| matches!(v, RustOptimize::Bool(false))) {
             eprintln!(
                 "WARNING: setting `optimize` to `false` is known to cause errors and \
                 should be considered unsupported. Refer to `bootstrap.example.toml` \
@@ -973,7 +973,7 @@ impl Config {
             // config to the ones used to build the LLVM artifacts on CI, and only notify users
             // if they've chosen a different value.
 
-            if llvm_libzstd_.is_some() {
+            if llvm_libzstd.is_some() {
                 println!(
                     "WARNING: when using `download-ci-llvm`, the local `llvm.libzstd` option, \
                     like almost all `llvm.*` options, will be ignored and set by the LLVM CI \
@@ -985,7 +985,7 @@ impl Config {
             }
         }
 
-        if !llvm_from_ci && llvm_thin_lto_.unwrap_or(false) && llvm_link_shared_.is_none() {
+        if !llvm_from_ci && llvm_thin_lto.unwrap_or(false) && llvm_link_shared_.is_none() {
             // If we're building with ThinLTO on, by default we want to link
             // to LLVM shared, to avoid re-doing ThinLTO (which happens in
             // the link step) with each stage.
@@ -1170,81 +1170,81 @@ impl Config {
                 Warnings::Default => rust_deny_warnings.unwrap_or(true),
             },
             backtrace_on_ice: rust_backtrace_on_ice.unwrap_or(false),
-            llvm_tests: llvm_tests_.unwrap_or_default(),
-            llvm_enzyme: llvm_enzyme_.unwrap_or_default(),
-            llvm_offload: llvm_offload_.unwrap_or(false),
+            llvm_tests: llvm_tests.unwrap_or_default(),
+            llvm_enzyme: llvm_enzyme.unwrap_or_default(),
+            llvm_offload: llvm_offload.unwrap_or(false),
             llvm_plugins: llvm_plugin.unwrap_or_default(),
-            llvm_optimize: llvm_optimize_.unwrap_or(true),
-            llvm_release_debuginfo: llvm_release_debuginfo_.unwrap_or(false),
+            llvm_optimize: llvm_optimize.unwrap_or(true),
+            llvm_release_debuginfo: llvm_release_debuginfo.unwrap_or(false),
             llvm_static_stdcpp: llvm_static_libstdcpp.unwrap_or(false),
-            llvm_libzstd: llvm_libzstd_.unwrap_or(false),
-            llvm_clang_cl: llvm_clang_cl_,
-            llvm_targets: llvm_targets_,
-            llvm_experimental_targets: llvm_experimental_targets_,
-            llvm_link_jobs: llvm_link_jobs_,
-            llvm_version_suffix: llvm_version_suffix_,
-            llvm_use_linker: llvm_use_linker_,
-            llvm_allow_old_toolchain: llvm_allow_old_toolchain_.unwrap_or(false),
-            llvm_polly: llvm_polly_.unwrap_or(false),
-            llvm_clang: llvm_clang_.unwrap_or(false),
-            llvm_enable_warnings: llvm_enable_warnings_.unwrap_or(false),
-            llvm_build_config: llvm_build_config_.clone().unwrap_or(Default::default()),
+            llvm_libzstd: llvm_libzstd.unwrap_or(false),
+            llvm_clang_cl,
+            llvm_targets,
+            llvm_experimental_targets,
+            llvm_link_jobs,
+            llvm_version_suffix,
+            llvm_use_linker,
+            llvm_allow_old_toolchain: llvm_allow_old_toolchain.unwrap_or(false),
+            llvm_polly: llvm_polly.unwrap_or(false),
+            llvm_clang: llvm_clang.unwrap_or(false),
+            llvm_enable_warnings: llvm_enable_warnings.unwrap_or(false),
+            llvm_build_config: llvm_build_config.clone().unwrap_or(Default::default()),
             llvm_tools_enabled: rust_llvm_tools.unwrap_or(true),
             llvm_bitcode_linker_enabled: rust_llvm_bitcode_linker.unwrap_or(false),
-            llvm_cflags: llvm_cflags_,
-            llvm_cxxflags: llvm_cxxflags_,
-            llvm_ldflags: llvm_ldflags_,
-            llvm_use_libcxx: llvm_use_libcxx_.unwrap_or(false),
+            llvm_cflags,
+            llvm_cxxflags,
+            llvm_ldflags,
+            llvm_use_libcxx: llvm_use_libcxx.unwrap_or(false),
             gcc_ci_mode: match gcc_download_ci_gcc {
                 Some(value) => match value {
                     true => GccCiMode::DownloadFromCi,
                     false => GccCiMode::BuildLocally,
                 },
                 None => GccCiMode::default(),
             },
-            rust_optimize: rust_optimize_.unwrap_or(RustOptimize::Bool(true)),
-            rust_codegen_units: rust_codegen_units_.map(threads_from_config),
-            rust_codegen_units_std: rust_codegen_units_std_.map(threads_from_config),
+            rust_optimize: rust_optimize.unwrap_or(RustOptimize::Bool(true)),
+            rust_codegen_units: rust_codegen_units.map(threads_from_config),
+            rust_codegen_units_std: rust_codegen_units_std.map(threads_from_config),
             std_debug_assertions: rust_std_debug_assertions
                 .or(rust_rustc_debug_assertions)
                 .unwrap_or(rust_debug == Some(true)),
             tools_debug_assertions: rust_tools_debug_assertions
                 .or(rust_rustc_debug_assertions)
                 .unwrap_or(rust_debug == Some(true)),
-            rust_overflow_checks_std: rust_overflow_checks_std_
-                .or(rust_overflow_checks_)
+            rust_overflow_checks_std: rust_overflow_checks_std
+                .or(rust_overflow_checks)
                 .unwrap_or(rust_debug == Some(true)),
-            rust_overflow_checks: rust_overflow_checks_.unwrap_or(rust_debug == Some(true)),
-            rust_debug_logging: rust_debug_logging_
+            rust_overflow_checks: rust_overflow_checks.unwrap_or(rust_debug == Some(true)),
+            rust_debug_logging: rust_debug_logging
                 .or(rust_rustc_debug_assertions)
                 .unwrap_or(rust_debug == Some(true)),
-            rust_debuginfo_level_rustc: with_defaults(rust_debuginfo_level_rustc_),
-            rust_debuginfo_level_std: with_defaults(rust_debuginfo_level_std_),
-            rust_debuginfo_level_tools: with_defaults(rust_debuginfo_level_tools_),
-            rust_debuginfo_level_tests: rust_debuginfo_level_tests_.unwrap_or(DebuginfoLevel::None),
-            rust_rpath: rust_rpath_.unwrap_or(true),
-            rust_strip: rust_strip_.unwrap_or(false),
-            rust_frame_pointers: rust_frame_pointers_.unwrap_or(false),
-            rust_stack_protector: rust_stack_protector_,
+            rust_debuginfo_level_rustc: with_defaults(rust_debuginfo_level_rustc),
+            rust_debuginfo_level_std: with_defaults(rust_debuginfo_level_std),
+            rust_debuginfo_level_tools: with_defaults(rust_debuginfo_level_tools),
+            rust_debuginfo_level_tests: rust_debuginfo_level_tests.unwrap_or(DebuginfoLevel::None),
+            rust_rpath: rust_rpath.unwrap_or(true),
+            rust_strip: rust_strip.unwrap_or(false),
+            rust_frame_pointers: rust_frame_pointers.unwrap_or(false),
+            rust_stack_protector,
             rustc_default_linker: rust_default_linker,
-            rust_optimize_tests: rust_optimize_tests_.unwrap_or(true),
-            rust_dist_src: dist_src_tarball_.unwrap_or_else(|| rust_dist_src_.unwrap_or(true)),
-            rust_codegen_backends: rust_codegen_backends_
+            rust_optimize_tests: rust_optimize_tests.unwrap_or(true),
+            rust_dist_src: dist_src_tarball.unwrap_or_else(|| rust_dist_src.unwrap_or(true)),
+            rust_codegen_backends: rust_codegen_backends
                 .map(|backends| parse_codegen_backends(backends, "rust"))
                 .unwrap_or(vec![CodegenBackendKind::Llvm]),
-            rust_verify_llvm_ir: rust_verify_llvm_ir_.unwrap_or(false),
-            rust_thin_lto_import_instr_limit: rust_thin_lto_import_instr_limit_,
-            rust_randomize_layout: rust_randomize_layout_.unwrap_or_default(),
-            rust_remap_debuginfo: rust_remap_debuginfo_.unwrap_or(false),
-            rust_new_symbol_mangling: rust_new_symbol_mangling_,
-            rust_profile_use: flags_rust_profile_use.or(rust_profile_use_),
-            rust_profile_generate: flags_rust_profile_generate.or(rust_profile_generate_),
-            rust_lto: rust_lto_
+            rust_verify_llvm_ir: rust_verify_llvm_ir.unwrap_or(false),
+            rust_thin_lto_import_instr_limit,
+            rust_randomize_layout: rust_randomize_layout.unwrap_or_default(),
+            rust_remap_debuginfo: rust_remap_debuginfo.unwrap_or(false),
+            rust_new_symbol_mangling,
+            rust_profile_use: flags_rust_profile_use.or(rust_profile_use),
+            rust_profile_generate: flags_rust_profile_generate.or(rust_profile_generate),
+            rust_lto: rust_lto
                 .as_deref()
                 .map(|value| RustcLto::from_str(value).unwrap())
                 .unwrap_or_default(),
-            rust_validate_mir_opts: rust_validate_mir_opts_,
-            rust_std_features: rust_std_features_
+            rust_validate_mir_opts,
+            rust_std_features: rust_std_features
                 .unwrap_or(BTreeSet::from([String::from("panic-unwind")])),
             llvm_profile_use: flags_llvm_profile_use,
             llvm_profile_generate: flags_llvm_profile_generate,
@@ -1256,11 +1256,11 @@ impl Config {
             jemalloc: rust_jemalloc.unwrap_or(false),
             control_flow_guard: rust_control_flow_guard.unwrap_or(false),
             ehcont_guard: rust_ehcont_guard.unwrap_or(false),
-            dist_sign_folder: dist_sign_folder_.map(PathBuf::from),
-            dist_upload_addr: dist_upload_addr_,
-            dist_compression_formats: dist_compression_formats_,
-            dist_compression_profile: dist_compression_profile_.unwrap_or("fast".into()),
-            dist_include_mingw_linker: dist_include_mingw_linker_.unwrap_or(true),
+            dist_sign_folder: dist_sign_folder.map(PathBuf::from),
+            dist_upload_addr,
+            dist_compression_formats,
+            dist_compression_profile: dist_compression_profile.unwrap_or("fast".into()),
+            dist_include_mingw_linker: dist_include_mingw_linker.unwrap_or(true),
             backtrace: rust_backtrace.unwrap_or(true),
             low_priority: build_low_priority.unwrap_or(false),
             description: build_description,
@@ -1302,7 +1302,7 @@ impl Config {
             enzyme_info: git_info(&exec_ctx, omit_git_hash, &src.join("src/tools/enzyme")),
             in_tree_llvm_info: git_info(&exec_ctx, false, &src.join("src/llvm-project")),
             in_tree_gcc_info: git_info(&exec_ctx, false, &src.join("src/gcc")),
-            dist_vendor: dist_vendor_.unwrap_or_else(|| {
+            dist_vendor: dist_vendor.unwrap_or_else(|| {
                 // If we're building from git or tarball sources, enable it by default.
                 rust_info.is_managed_git_subrepository() || rust_info.is_from_tarball()
             }),
@@ -1332,7 +1332,7 @@ impl Config {
                 .collect(),
             paths: flags_paths,
             config: toml_path,
-            llvm_thin_lto: llvm_thin_lto_.unwrap_or(false),
+            llvm_thin_lto: llvm_thin_lto.unwrap_or(false),
             rustc_debug_assertions: rust_rustc_debug_assertions.unwrap_or(rust_debug == Some(true)),
             lld_mode: rust_lld_mode.unwrap_or_default(),
             initial_cargo_clippy: build_cargo_clippy,