move min_config related options from config module

Signed-off-by: ozkanonur <work@onurozkan.dev>

Author: onur-ozkan

src/bootstrap/bin/bootstrap-shim.rs

@@ -1,19 +1,17 @@
 use std::{env, process::Command};
 
-use bootstrap::{t, MinimalConfig};
+use bootstrap::{Flags, MinimalConfig};
 
 #[path = "../../../src/tools/x/src/main.rs"]
 mod run_python;
 
 fn main() {
     let args = env::args().skip(1).collect::<Vec<_>>();
-    let mut opts = getopts::Options::new();
-    opts.optopt("", "config", "TOML configuration file for build", "FILE");
-    let matches = t!(opts.parse(args));
+    let flags = Flags::parse(&args);
 
     // If there are no untracked changes to bootstrap, download it from CI.
     // Otherwise, build it from source. Use python to build to avoid duplicating the code between python and rust.
-    let config = MinimalConfig::parse(t!(matches.opt_get("config")));
+    let config = MinimalConfig::parse(&flags, None);
     let bootstrap_bin = if let Some(commit) = last_modified_bootstrap_commit(&config) {
         config.download_bootstrap(&commit)
     } else {

src/bootstrap/bin/main.rs

@@ -13,7 +13,7 @@ use bootstrap::{Build, Config, Subcommand, VERSION};
 
 fn main() {
     let args = env::args().skip(1).collect::<Vec<_>>();
-    let config = Config::parse(&args);
+    let config = Config::parse(&args, None);
 
     #[cfg(all(any(unix, windows), not(target_os = "solaris")))]
     let mut build_lock;

src/bootstrap/builder/tests.rs

@@ -7,7 +7,7 @@ fn configure(cmd: &str, host: &[&str], target: &[&str]) -> Config {
 }
 
 fn configure_with_args(cmd: &[String], host: &[&str], target: &[&str]) -> Config {
-    let mut config = Config::parse(cmd);
+    let mut config = Config::parse(cmd, None);
     // don't save toolstates
     config.save_toolstates = None;
     config.dry_run = DryRun::SelfCheck;
@@ -18,7 +18,7 @@ fn configure_with_args(cmd: &[String], host: &[&str], target: &[&str]) -> Config
     let submodule_build = Build::new(Config {
         // don't include LLVM, so CI doesn't require ninja/cmake to be installed
         rust_codegen_backends: vec![],
-        ..Config::parse(&["check".to_owned()])
+        ..Config::parse(&["check".to_owned()], None)
     });
     submodule_build.update_submodule(Path::new("src/doc/book"));
     submodule_build.update_submodule(Path::new("src/tools/rust-analyzer"));

src/bootstrap/config.rs

@@ -7,9 +7,7 @@
 mod tests;
 
 use std::cell::{Cell, RefCell};
-use std::cmp;
 use std::collections::{HashMap, HashSet};
-use std::env;
 use std::fs;
 use std::ops::{Deref, DerefMut};
 use std::path::{Path, PathBuf};
@@ -22,9 +20,7 @@ use crate::cc_detect::{ndk_compiler, Language};
 use crate::channel::{self, GitInfo};
 pub use crate::flags::Subcommand;
 use crate::flags::{Color, Flags, Warnings};
-use crate::min_config::{
-    deserialize_stage0_metadata, get_toml, set_and_return_toml_config, set_config_output_dir,
-};
+use crate::min_config::{get_toml, set_cfg_path_and_return_toml_cfg};
 use crate::util::{exe, output, t};
 use crate::MinimalConfig;
 use once_cell::sync::OnceCell;
@@ -391,14 +387,15 @@ impl Target {
         target
     }
 }
+
 /// Structure of the `config.toml` file that configuration is read from.
 ///
 /// This structure uses `Decodable` to automatically decode a TOML configuration
 /// file into this format, and then this is traversed and written into the above
 /// `Config` structure.
 #[derive(Deserialize, Default)]
 #[serde(deny_unknown_fields, rename_all = "kebab-case")]
-struct TomlConfig {
+pub struct TomlConfig {
     changelog_seen: Option<usize>,
     build: Option<Build>,
     install: Option<Install>,
@@ -443,8 +440,8 @@ macro_rules! define_config {
         $($field:ident: Option<$field_ty:ty> = $field_key:literal,)*
     }) => {
         $(#[$attr])*
-        struct $name {
-            $($field: Option<$field_ty>,)*
+        pub struct $name {
+            $(pub(crate) $field: Option<$field_ty>,)*
         }
 
         impl Merge for $name {
@@ -526,7 +523,7 @@ macro_rules! define_config {
 
 define_config! {
     /// TOML representation of various global build decisions.
-    #[derive(Default)]
+    #[derive(Clone, Default)]
     struct Build {
         build: Option<String> = "build",
         host: Option<Vec<String>> = "host",
@@ -632,7 +629,7 @@ define_config! {
 
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
-enum StringOrBool {
+pub(crate) enum StringOrBool {
     String(String),
     Bool(bool),
 }
@@ -752,14 +749,6 @@ impl Config {
         config.stdout_is_tty = std::io::stdout().is_terminal();
         config.stderr_is_tty = std::io::stderr().is_terminal();
 
-        // set by build.rs
-        config.build = TargetSelection::from_user(&env!("BUILD_TRIPLE"));
-
-        let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        // Undo `src/bootstrap`
-        config.src = manifest_dir.parent().unwrap().parent().unwrap().to_owned();
-        config.out = PathBuf::from("build");
-
         config
     }
 
@@ -785,10 +774,19 @@ impl Config {
         args
     }
 
-    pub fn parse(args: &[String]) -> Config {
+    pub fn parse(args: &[String], custom_toml_config: Option<TomlConfig>) -> Config {
         let mut flags = Flags::parse(&args);
         let mut config = Config::default_opts();
-        config.minimal_config = MinimalConfig::parse(flags.config.clone());
+
+        let mut toml: TomlConfig = custom_toml_config.unwrap_or_else(|| {
+            set_cfg_path_and_return_toml_cfg(
+                config.src.clone(),
+                flags.config.clone(),
+                &mut config.config,
+            )
+        });
+
+        config.minimal_config = MinimalConfig::parse(&flags, toml.build.clone());
 
         // Set flags.
         config.paths = std::mem::take(&mut flags.paths);
@@ -800,7 +798,6 @@ impl Config {
         config.jobs = Some(threads_from_config(flags.jobs as u32));
         config.cmd = flags.cmd;
         config.incremental = flags.incremental;
-        config.dry_run = if flags.dry_run { DryRun::UserSelected } else { DryRun::Disabled };
         config.keep_stage = flags.keep_stage;
         config.keep_stage_std = flags.keep_stage_std;
         config.color = flags.color;
@@ -817,13 +814,10 @@ impl Config {
             crate::detail_exit(1);
         }
 
-        // Infer the rest of the configuration.
-
-        set_config_output_dir(&mut config.out);
-        config.stage0_metadata = deserialize_stage0_metadata(&config.src);
-
-        let mut toml: TomlConfig =
-            set_and_return_toml_config(config.src.clone(), flags.config, &mut config.config);
+        let build = toml.build.clone().unwrap_or_default();
+        if let Some(file_build) = build.build.as_ref() {
+            config.build = TargetSelection::from_user(file_build);
+        };
 
         if let Some(include) = &toml.profile {
             let mut include_path = config.src.clone();
@@ -837,11 +831,6 @@ impl Config {
 
         config.changelog_seen = toml.changelog_seen;
 
-        let build = toml.build.unwrap_or_default();
-        if let Some(file_build) = build.build {
-            config.build = TargetSelection::from_user(&file_build);
-        };
-
         set(&mut config.out, flags.build_dir.or_else(|| build.build_dir.map(PathBuf::from)));
         // NOTE: Bootstrap spawns various commands with different working directories.
         // To avoid writing to random places on the file system, `config.out` needs to be an absolute path.
@@ -902,17 +891,13 @@ impl Config {
         set(&mut config.full_bootstrap, build.full_bootstrap);
         set(&mut config.extended, build.extended);
         config.tools = build.tools;
-        set(&mut config.verbose, build.verbose);
         set(&mut config.sanitizers, build.sanitizers);
         set(&mut config.profiler, build.profiler);
         set(&mut config.cargo_native_static, build.cargo_native_static);
         set(&mut config.configure_args, build.configure_args);
         set(&mut config.local_rebuild, build.local_rebuild);
         set(&mut config.print_step_timings, build.print_step_timings);
         set(&mut config.print_step_rusage, build.print_step_rusage);
-        set(&mut config.patch_binaries_for_nix, build.patch_binaries_for_nix);
-
-        config.verbose = cmp::max(config.verbose, flags.verbose as usize);
 
         if let Some(install) = toml.install {
             config.prefix = install.prefix.map(PathBuf::from);
@@ -1526,7 +1511,7 @@ impl Config {
     }
 }
 
-fn set<T>(field: &mut T, val: Option<T>) {
+pub(crate) fn set<T>(field: &mut T, val: Option<T>) {
     if let Some(v) = val {
         *field = v;
     }

src/bootstrap/config/tests.rs

@@ -2,12 +2,12 @@ use super::{Config, Flags, TomlConfig};
 use clap::CommandFactory;
 use std::{env, path::Path};
 
-fn toml(config: &str) -> impl '_ + Fn(&Path) -> TomlConfig {
-    |&_| toml::from_str(config).unwrap()
+fn toml(config: &str) -> TomlConfig {
+    toml::from_str(config).unwrap()
 }
 
 fn parse(config: &str) -> Config {
-    Config::parse_inner(&["check".to_owned(), "--config=/does/not/exist".to_owned()], toml(config))
+    Config::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()], Some(toml(config)))
 }
 
 #[test]

src/bootstrap/flags.rs

@@ -183,7 +183,7 @@ impl Flags {
             HelpVerboseOnly::try_parse_from(it.clone())
         {
             println!("note: updating submodules before printing available paths");
-            let config = Config::parse(&[String::from("build")]);
+            let config = Config::parse(&[String::from("build")], None);
             let build = Build::new(config);
             let paths = Builder::get_help(&build, subcommand);
             if let Some(s) = paths {

src/bootstrap/lib.rs

@@ -90,6 +90,7 @@ mod job {
 pub use crate::builder::PathSet;
 use crate::cache::{Interned, INTERNER};
 pub use crate::config::Config;
+pub use crate::flags::Flags;
 pub use crate::flags::Subcommand;
 pub use crate::min_config::MinimalConfig;
 use termcolor::{ColorChoice, StandardStream, WriteColor};

src/bootstrap/min_config.rs

@@ -1,5 +1,6 @@
 use core::fmt;
 use std::{
+    cmp,
     collections::HashMap,
     env, fs,
     path::{Path, PathBuf},
@@ -11,6 +12,8 @@ use serde_derive::Deserialize;
 
 use crate::{
     cache::{Interned, INTERNER},
+    config::{self, set},
+    flags::Flags,
     t,
     util::output,
 };
@@ -91,22 +94,40 @@ impl MinimalConfig {
         }
     }
 
-    pub fn parse(config_flag: Option<PathBuf>) -> MinimalConfig {
+    fn set_shared_fields_from_parent(&mut self, parent_build_config: config::Build) {
+        set(&mut self.verbose, parent_build_config.verbose);
+        set(&mut self.patch_binaries_for_nix, parent_build_config.patch_binaries_for_nix);
+    }
+
+    pub fn parse(flags: &Flags, parent_build_config: Option<config::Build>) -> MinimalConfig {
         let mut config = Self::default_opts();
 
+        if let Some(parent_build_config) = parent_build_config {
+            config.set_shared_fields_from_parent(parent_build_config);
+        };
+
         if let Some(src) = src() {
             config.src = src;
         }
 
         set_config_output_dir(&mut config.out);
 
-        let toml: TomlConfig =
-            set_and_return_toml_config(config.src.clone(), config_flag, &mut config.config);
+        config.stage0_metadata = deserialize_stage0_metadata(&config.src);
+        config.dry_run = if flags.dry_run { DryRun::UserSelected } else { DryRun::Disabled };
+
+        let toml: TomlConfig = set_cfg_path_and_return_toml_cfg(
+            config.src.clone(),
+            flags.config.clone(),
+            &mut config.config,
+        );
 
-        if let Some(build) = toml.build.unwrap_or_default().build {
-            config.build = TargetSelection::from_user(&build);
+        let build = toml.build.unwrap_or_default();
+        if let Some(file_build) = build.build {
+            config.build = TargetSelection::from_user(&file_build);
         }
 
+        config.verbose = cmp::max(config.verbose, flags.verbose as usize);
+
         if config.dry_run() {
             let dir = config.out.join("tmp-dry-run");
             t!(fs::create_dir_all(&dir));
@@ -229,10 +250,8 @@ pub(crate) fn get_toml<T: Deserialize<'static> + Default>(file: &Path) -> T {
 /// Shared helper function to be used in `MinimalConfig::parse` and `bootstrap::config::Config::parse`
 ///
 /// Use the build directory of the original x.py invocation, so that we can set `initial_rustc` properly.
-#[allow(unused_variables)]
-pub(crate) fn set_config_output_dir(output_path: &mut PathBuf) {
-    #[cfg(test)]
-    {
+fn set_config_output_dir(output_path: &mut PathBuf) {
+    if cfg!(test) {
         *output_path = Path::new(
             &env::var_os("CARGO_TARGET_DIR").expect("cargo test directly is not supported"),
         )
@@ -243,7 +262,7 @@ pub(crate) fn set_config_output_dir(output_path: &mut PathBuf) {
 }
 
 /// Shared helper function to be used in `MinimalConfig::parse` and `bootstrap::config::Config::parse`
-pub(crate) fn set_and_return_toml_config<T: Deserialize<'static> + Default>(
+pub(crate) fn set_cfg_path_and_return_toml_cfg<T: Deserialize<'static> + Default>(
     src: PathBuf,
     config_flag: Option<PathBuf>,
     cfg_path: &mut Option<PathBuf>,