// should run on success, after this block.

}

if verbose > 0 {

}

if let Some(mut on_fail) = on_fail {

fn run(self, builder: &Builder<'_>) {

// FIXME: remove once https://github.com/rust-lang/rust/issues/112393 is resolved

if builder.build.config.vendor && self.backend == "gcc" {

return;

}

let sysroot = sysroot_dir(compiler.stage);

builder

let _ = fs::remove_dir_all(&sysroot);

t!(fs::create_dir_all(&sysroot));

return true;

}

if !filtered_files.iter().all(|f| f != path.file_name().unwrap()) {

false

} else {

true

cargo.arg(arg);

}

if builder.config.dry_run() {

return true;

cb(msg)

}

// If this was informational, just print it out and continue

}

}

{

let mut cmd = command(llvm_config);

cmd.arg("--libfiles");

let files = cmd.run_capture_stdout(builder).stdout();

let build_llvm_out = &builder.llvm_out(builder.config.build);

let target_llvm_out = &builder.llvm_out(target);

if let Some(adjective) = adjective { format!("{adjective} ") } else { String::new() };

if len <= 10 {

for path in paths {

}

} else {

}

}

match get_modified_rs_files(build) {

Ok(Some(files)) => {

if files.is_empty() {

return;

}

t!(fs::remove_file(path));

}

_ => {

crate::exit!(1);

}

}

Profile::Dist => &["dist", "build"],

};

for cmd in suggestions {

}

if profile != Profile::Dist {

"For more suggestions, see https://rustc-dev-guide.rust-lang.org/building/suggested.html"

);

}

t!(fs::write(path, settings));

let include_path = profile.include_path(&config.src);

}

/// Creates a toolchain link for stage1 using `rustup`

}

if !rustup_installed(builder) {

return;

}

}

if try_link_toolchain(builder, stage_path) {

"Added `stage1` rustup toolchain; try `cargo +stage1 build` on a separate rust project to run a newly-built toolchain"

);

} else {

return false;

}

// The toolchain has already been linked.

"`stage1` toolchain already linked; not attempting to link `stage1` toolchain"

);

}

None => {

// In this case, we don't know if the `stage1` toolchain has been linked;

// but `rustup` failed, so let's not go any further.

"`rustup` failed to list current toolchains; not attempting to link `stage1` toolchain"

);

}

input.parse()

}

for ((letter, _), profile) in abbrev_all() {

}

let template = loop {

"Please choose one ({}): ",

abbrev_all().map(|((l, _), _)| l).collect::<Vec<_>>().join("/")

);

fn prompt_user(prompt: &str) -> io::Result<Option<PromptResult>> {

let mut input = String::new();

loop {

io::stdout().flush()?;

input.clear();

io::stdin().read_line(&mut input)?;

return Ok(());

}

"\nRust's CI will automatically fail if it doesn't pass `tidy`, the internal tool for ensuring code quality.

If you'd like, x.py can install a git hook for you that will automatically run `test tidy` before

pushing your code to ensure your code is up to par. If you decide later that this behavior is

undesirable, simply delete the `pre-push` file from .git/hooks."

);

if prompt_user("Would you like to install the git hook?: [y/N]")? != Some(PromptResult::Yes) {

return Ok(());

}

if !hooks_dir.exists() {

);

return Err(e);

}

};

Ok(())

}

let mut input = String::new();

loop {

io::stdout().flush()?;

input.clear();

io::stdin().read_line(&mut input)?;

if let Some(editor_kind) = editor_kind {

while !t!(create_editor_settings_maybe(config, editor_kind.clone())) {}

} else {

}

}

Err(e) => eprintln!("Could not determine the editor: {e}"),

mismatched_settings = Some(false);

}

}

"\nx.py can automatically install the recommended `{settings_filename}` file for rustc development"

);

Some(PromptResult::Yes) => true,

Some(PromptResult::Print) => false,

_ => {

return Ok(true);

}

};

_ => "Created",

};

fs::write(&settings_path, editor.settings_template())?;

} else {

}

Ok(should_create)

}

build.build();

}

} else {

}

}

// We re-use the `cargo` from above.

cargo.arg("--print-sysroot");

let stdout = cargo.run_capture_stdout(builder).stdout();

// Output is "<sysroot>\n".

let sysroot = stdout.trim_end();

PathBuf::from(sysroot)

}

}

}

}

let mut cmd = builder.rustdoc_cmd(compiler);

builder.add_rust_test_threads(&mut cmd);

// allow for unstable options such as new editions

let sysroot_str = sysroot.as_os_str().to_str().expect("sysroot should be UTF-8");

if self.is_verbose() && !matches!(self.config.dry_run, DryRun::SelfCheck) {

}

let mut rustflags = Rustflags::new(target);