1use std::collections::{BTreeSet, HashMap, HashSet};
40use std::ffi::OsString;
41use std::io::Write;
42use std::path::{Path, PathBuf};
43use std::process::{self, ExitStatus, Output};
44use std::{env, fs, str};
45
46use anyhow::{bail, Context as _};
47use cargo_util::{exit_status_to_string, is_simple_exit_code, paths, ProcessBuilder};
48use cargo_util_schemas::manifest::TomlManifest;
49use rustfix::diagnostics::Diagnostic;
50use rustfix::CodeFix;
51use semver::Version;
52use tracing::{debug, trace, warn};
53
54pub use self::fix_edition::fix_edition;
55use crate::core::compiler::CompileKind;
56use crate::core::compiler::RustcTargetData;
57use crate::core::resolver::features::{DiffMap, FeatureOpts, FeatureResolver, FeaturesFor};
58use crate::core::resolver::{HasDevUnits, Resolve, ResolveBehavior};
59use crate::core::PackageIdSpecQuery as _;
60use crate::core::{Edition, MaybePackage, Package, PackageId, Workspace};
61use crate::ops::resolve::WorkspaceResolve;
62use crate::ops::{self, CompileOptions};
63use crate::util::diagnostic_server::{Message, RustfixDiagnosticServer};
64use crate::util::errors::CargoResult;
65use crate::util::toml_mut::manifest::LocalManifest;
66use crate::util::GlobalContext;
67use crate::util::{existing_vcs_repo, LockServer, LockServerClient};
68use crate::{drop_eprint, drop_eprintln};
69
70mod fix_edition;
71
72const FIX_ENV_INTERNAL: &str = "__CARGO_FIX_PLZ";
77const BROKEN_CODE_ENV_INTERNAL: &str = "__CARGO_FIX_BROKEN_CODE";
80const EDITION_ENV_INTERNAL: &str = "__CARGO_FIX_EDITION";
83const IDIOMS_ENV_INTERNAL: &str = "__CARGO_FIX_IDIOMS";
86const SYSROOT_INTERNAL: &str = "__CARGO_FIX_RUST_SRC";
94
95pub struct FixOptions {
96 pub edition: Option<EditionFixMode>,
97 pub idioms: bool,
98 pub compile_opts: CompileOptions,
99 pub allow_dirty: bool,
100 pub allow_no_vcs: bool,
101 pub allow_staged: bool,
102 pub broken_code: bool,
103 pub requested_lockfile_path: Option<PathBuf>,
104}
105
106#[derive(Clone, Copy)]
108pub enum EditionFixMode {
109 NextRelative,
113 OverrideSpecific(Edition),
118}
119
120impl EditionFixMode {
121 pub fn next_edition(&self, current_edition: Edition) -> Edition {
123 match self {
124 EditionFixMode::NextRelative => current_edition.saturating_next(),
125 EditionFixMode::OverrideSpecific(edition) => *edition,
126 }
127 }
128
129 fn to_string(&self) -> String {
131 match self {
132 EditionFixMode::NextRelative => "1".to_string(),
133 EditionFixMode::OverrideSpecific(edition) => edition.to_string(),
134 }
135 }
136
137 fn from_str(s: &str) -> EditionFixMode {
139 match s {
140 "1" => EditionFixMode::NextRelative,
141 edition => EditionFixMode::OverrideSpecific(edition.parse().unwrap()),
142 }
143 }
144}
145
146pub fn fix(
147 gctx: &GlobalContext,
148 original_ws: &Workspace<'_>,
149 opts: &mut FixOptions,
150) -> CargoResult<()> {
151 check_version_control(gctx, opts)?;
152
153 let mut target_data =
154 RustcTargetData::new(original_ws, &opts.compile_opts.build_config.requested_kinds)?;
155 if let Some(edition_mode) = opts.edition {
156 let specs = opts.compile_opts.spec.to_package_id_specs(&original_ws)?;
157 let members: Vec<&Package> = original_ws
158 .members()
159 .filter(|m| specs.iter().any(|spec| spec.matches(m.package_id())))
160 .collect();
161 migrate_manifests(original_ws, &members, edition_mode)?;
162
163 check_resolver_change(&original_ws, &mut target_data, opts)?;
164 }
165 let ws = original_ws.reload(gctx)?;
166
167 let lock_server = LockServer::new()?;
169 let mut wrapper = ProcessBuilder::new(env::current_exe()?);
170 wrapper.env(FIX_ENV_INTERNAL, lock_server.addr().to_string());
171 let _started = lock_server.start()?;
172
173 opts.compile_opts.build_config.force_rebuild = true;
174
175 if opts.broken_code {
176 wrapper.env(BROKEN_CODE_ENV_INTERNAL, "1");
177 }
178
179 if let Some(mode) = &opts.edition {
180 wrapper.env(EDITION_ENV_INTERNAL, mode.to_string());
181 }
182 if opts.idioms {
183 wrapper.env(IDIOMS_ENV_INTERNAL, "1");
184 }
185
186 let sysroot = &target_data.info(CompileKind::Host).sysroot;
187 if sysroot.is_dir() {
188 wrapper.env(SYSROOT_INTERNAL, sysroot);
189 }
190
191 *opts
192 .compile_opts
193 .build_config
194 .rustfix_diagnostic_server
195 .borrow_mut() = Some(RustfixDiagnosticServer::new()?);
196
197 if let Some(server) = opts
198 .compile_opts
199 .build_config
200 .rustfix_diagnostic_server
201 .borrow()
202 .as_ref()
203 {
204 server.configure(&mut wrapper);
205 }
206
207 let rustc = ws.gctx().load_global_rustc(Some(&ws))?;
208 wrapper.arg(&rustc.path);
209 wrapper.retry_with_argfile(true);
212
213 opts.compile_opts.build_config.primary_unit_rustc = Some(wrapper);
216
217 ops::compile(&ws, &opts.compile_opts)?;
218 Ok(())
219}
220
221fn check_version_control(gctx: &GlobalContext, opts: &FixOptions) -> CargoResult<()> {
222 if opts.allow_no_vcs {
223 return Ok(());
224 }
225 if !existing_vcs_repo(gctx.cwd(), gctx.cwd()) {
226 bail!(
227 "no VCS found for this package and `cargo fix` can potentially \
228 perform destructive changes; if you'd like to suppress this \
229 error pass `--allow-no-vcs`"
230 )
231 }
232
233 if opts.allow_dirty && opts.allow_staged {
234 return Ok(());
235 }
236
237 let mut dirty_files = Vec::new();
238 let mut staged_files = Vec::new();
239 if let Ok(repo) = git2::Repository::discover(gctx.cwd()) {
240 let mut repo_opts = git2::StatusOptions::new();
241 repo_opts.include_ignored(false);
242 repo_opts.include_untracked(true);
243 for status in repo.statuses(Some(&mut repo_opts))?.iter() {
244 if let Some(path) = status.path() {
245 match status.status() {
246 git2::Status::CURRENT => (),
247 git2::Status::INDEX_NEW
248 | git2::Status::INDEX_MODIFIED
249 | git2::Status::INDEX_DELETED
250 | git2::Status::INDEX_RENAMED
251 | git2::Status::INDEX_TYPECHANGE => {
252 if !opts.allow_staged {
253 staged_files.push(path.to_string())
254 }
255 }
256 _ => {
257 if !opts.allow_dirty {
258 dirty_files.push(path.to_string())
259 }
260 }
261 };
262 }
263 }
264 }
265
266 if dirty_files.is_empty() && staged_files.is_empty() {
267 return Ok(());
268 }
269
270 let mut files_list = String::new();
271 for file in dirty_files {
272 files_list.push_str(" * ");
273 files_list.push_str(&file);
274 files_list.push_str(" (dirty)\n");
275 }
276 for file in staged_files {
277 files_list.push_str(" * ");
278 files_list.push_str(&file);
279 files_list.push_str(" (staged)\n");
280 }
281
282 bail!(
283 "the working directory of this package has uncommitted changes, and \
284 `cargo fix` can potentially perform destructive changes; if you'd \
285 like to suppress this error pass `--allow-dirty`, \
286 or commit the changes to these files:\n\
287 \n\
288 {}\n\
289 ",
290 files_list
291 );
292}
293
294fn migrate_manifests(
295 ws: &Workspace<'_>,
296 pkgs: &[&Package],
297 edition_mode: EditionFixMode,
298) -> CargoResult<()> {
299 if matches!(ws.root_maybe(), MaybePackage::Virtual(_)) {
302 let highest_edition = pkgs
305 .iter()
306 .map(|p| p.manifest().edition())
307 .max()
308 .unwrap_or_default();
309 let prepare_for_edition = edition_mode.next_edition(highest_edition);
310 if highest_edition == prepare_for_edition
311 || (!prepare_for_edition.is_stable() && !ws.gctx().nightly_features_allowed)
312 {
313 } else {
315 let mut manifest_mut = LocalManifest::try_new(ws.root_manifest())?;
316 let document = &mut manifest_mut.data;
317 let mut fixes = 0;
318
319 if Edition::Edition2024 <= prepare_for_edition {
320 let root = document.as_table_mut();
321
322 if let Some(workspace) = root
323 .get_mut("workspace")
324 .and_then(|t| t.as_table_like_mut())
325 {
326 fixes += rename_dep_fields_2024(workspace, "dependencies");
329 }
330 }
331
332 if 0 < fixes {
333 let file = ws.root_manifest();
336 let file = file.strip_prefix(ws.root()).unwrap_or(file);
337 let file = file.display();
338 ws.gctx().shell().status(
339 "Migrating",
340 format!("{file} from {highest_edition} edition to {prepare_for_edition}"),
341 )?;
342
343 let verb = if fixes == 1 { "fix" } else { "fixes" };
344 let msg = format!("{file} ({fixes} {verb})");
345 ws.gctx().shell().status("Fixed", msg)?;
346
347 manifest_mut.write()?;
348 }
349 }
350 }
351
352 for pkg in pkgs {
353 let existing_edition = pkg.manifest().edition();
354 let prepare_for_edition = edition_mode.next_edition(existing_edition);
355 if existing_edition == prepare_for_edition
356 || (!prepare_for_edition.is_stable() && !ws.gctx().nightly_features_allowed)
357 {
358 continue;
359 }
360 let file = pkg.manifest_path();
361 let file = file.strip_prefix(ws.root()).unwrap_or(file);
362 let file = file.display();
363 ws.gctx().shell().status(
364 "Migrating",
365 format!("{file} from {existing_edition} edition to {prepare_for_edition}"),
366 )?;
367
368 let mut manifest_mut = LocalManifest::try_new(pkg.manifest_path())?;
369 let document = &mut manifest_mut.data;
370 let mut fixes = 0;
371
372 let ws_original_toml = match ws.root_maybe() {
373 MaybePackage::Package(package) => package.manifest().original_toml(),
374 MaybePackage::Virtual(manifest) => manifest.original_toml(),
375 };
376 if Edition::Edition2024 <= prepare_for_edition {
377 let root = document.as_table_mut();
378
379 if let Some(workspace) = root
380 .get_mut("workspace")
381 .and_then(|t| t.as_table_like_mut())
382 {
383 fixes += rename_dep_fields_2024(workspace, "dependencies");
386 }
387
388 fixes += rename_table(root, "project", "package");
389 if let Some(target) = root.get_mut("lib").and_then(|t| t.as_table_like_mut()) {
390 fixes += rename_target_fields_2024(target);
391 }
392 fixes += rename_array_of_target_fields_2024(root, "bin");
393 fixes += rename_array_of_target_fields_2024(root, "example");
394 fixes += rename_array_of_target_fields_2024(root, "test");
395 fixes += rename_array_of_target_fields_2024(root, "bench");
396 fixes += rename_dep_fields_2024(root, "dependencies");
397 fixes += remove_ignored_default_features_2024(root, "dependencies", ws_original_toml);
398 fixes += rename_table(root, "dev_dependencies", "dev-dependencies");
399 fixes += rename_dep_fields_2024(root, "dev-dependencies");
400 fixes +=
401 remove_ignored_default_features_2024(root, "dev-dependencies", ws_original_toml);
402 fixes += rename_table(root, "build_dependencies", "build-dependencies");
403 fixes += rename_dep_fields_2024(root, "build-dependencies");
404 fixes +=
405 remove_ignored_default_features_2024(root, "build-dependencies", ws_original_toml);
406 for target in root
407 .get_mut("target")
408 .and_then(|t| t.as_table_like_mut())
409 .iter_mut()
410 .flat_map(|t| t.iter_mut())
411 .filter_map(|(_k, t)| t.as_table_like_mut())
412 {
413 fixes += rename_dep_fields_2024(target, "dependencies");
414 fixes +=
415 remove_ignored_default_features_2024(target, "dependencies", ws_original_toml);
416 fixes += rename_table(target, "dev_dependencies", "dev-dependencies");
417 fixes += rename_dep_fields_2024(target, "dev-dependencies");
418 fixes += remove_ignored_default_features_2024(
419 target,
420 "dev-dependencies",
421 ws_original_toml,
422 );
423 fixes += rename_table(target, "build_dependencies", "build-dependencies");
424 fixes += rename_dep_fields_2024(target, "build-dependencies");
425 fixes += remove_ignored_default_features_2024(
426 target,
427 "build-dependencies",
428 ws_original_toml,
429 );
430 }
431 }
432
433 if 0 < fixes {
434 let verb = if fixes == 1 { "fix" } else { "fixes" };
435 let msg = format!("{file} ({fixes} {verb})");
436 ws.gctx().shell().status("Fixed", msg)?;
437
438 manifest_mut.write()?;
439 }
440 }
441
442 Ok(())
443}
444
445fn rename_dep_fields_2024(parent: &mut dyn toml_edit::TableLike, dep_kind: &str) -> usize {
446 let mut fixes = 0;
447 for target in parent
448 .get_mut(dep_kind)
449 .and_then(|t| t.as_table_like_mut())
450 .iter_mut()
451 .flat_map(|t| t.iter_mut())
452 .filter_map(|(_k, t)| t.as_table_like_mut())
453 {
454 fixes += rename_table(target, "default_features", "default-features");
455 }
456 fixes
457}
458
459fn remove_ignored_default_features_2024(
460 parent: &mut dyn toml_edit::TableLike,
461 dep_kind: &str,
462 ws_original_toml: &TomlManifest,
463) -> usize {
464 let mut fixes = 0;
465 for (name_in_toml, target) in parent
466 .get_mut(dep_kind)
467 .and_then(|t| t.as_table_like_mut())
468 .iter_mut()
469 .flat_map(|t| t.iter_mut())
470 .filter_map(|(k, t)| t.as_table_like_mut().map(|t| (k, t)))
471 {
472 let name_in_toml: &str = &name_in_toml;
473 let ws_deps = ws_original_toml
474 .workspace
475 .as_ref()
476 .and_then(|ws| ws.dependencies.as_ref());
477 if let Some(ws_dep) = ws_deps.and_then(|ws_deps| ws_deps.get(name_in_toml)) {
478 if ws_dep.default_features() == Some(false) {
479 continue;
480 }
481 }
482 if target
483 .get("workspace")
484 .and_then(|i| i.as_value())
485 .and_then(|i| i.as_bool())
486 == Some(true)
487 && target
488 .get("default-features")
489 .and_then(|i| i.as_value())
490 .and_then(|i| i.as_bool())
491 == Some(false)
492 {
493 target.remove("default-features");
494 fixes += 1;
495 }
496 }
497 fixes
498}
499
500fn rename_array_of_target_fields_2024(root: &mut dyn toml_edit::TableLike, kind: &str) -> usize {
501 let mut fixes = 0;
502 for target in root
503 .get_mut(kind)
504 .and_then(|t| t.as_array_of_tables_mut())
505 .iter_mut()
506 .flat_map(|t| t.iter_mut())
507 {
508 fixes += rename_target_fields_2024(target);
509 }
510 fixes
511}
512
513fn rename_target_fields_2024(target: &mut dyn toml_edit::TableLike) -> usize {
514 let mut fixes = 0;
515 fixes += rename_table(target, "crate_type", "crate-type");
516 fixes += rename_table(target, "proc_macro", "proc-macro");
517 fixes
518}
519
520fn rename_table(parent: &mut dyn toml_edit::TableLike, old: &str, new: &str) -> usize {
521 let Some(old_key) = parent.key(old).cloned() else {
522 return 0;
523 };
524
525 let project = parent.remove(old).expect("returned early");
526 if !parent.contains_key(new) {
527 parent.insert(new, project);
528 let mut new_key = parent.key_mut(new).expect("just inserted");
529 *new_key.dotted_decor_mut() = old_key.dotted_decor().clone();
530 *new_key.leaf_decor_mut() = old_key.leaf_decor().clone();
531 }
532 1
533}
534
535fn check_resolver_change<'gctx>(
536 ws: &Workspace<'gctx>,
537 target_data: &mut RustcTargetData<'gctx>,
538 opts: &FixOptions,
539) -> CargoResult<()> {
540 let root = ws.root_maybe();
541 match root {
542 MaybePackage::Package(root_pkg) => {
543 if root_pkg.manifest().resolve_behavior().is_some() {
544 return Ok(());
546 }
547 let pkgs = opts.compile_opts.spec.get_packages(ws)?;
549 if !pkgs.contains(&root_pkg) {
550 return Ok(());
552 }
553 if root_pkg.manifest().edition() != Edition::Edition2018 {
554 return Ok(());
556 }
557 }
558 MaybePackage::Virtual(_vm) => {
559 return Ok(());
561 }
562 }
563 assert_eq!(ws.resolve_behavior(), ResolveBehavior::V1);
565 let specs = opts.compile_opts.spec.to_package_id_specs(ws)?;
566 let mut resolve_differences = |has_dev_units| -> CargoResult<(WorkspaceResolve<'_>, DiffMap)> {
567 let dry_run = false;
568 let ws_resolve = ops::resolve_ws_with_opts(
569 ws,
570 target_data,
571 &opts.compile_opts.build_config.requested_kinds,
572 &opts.compile_opts.cli_features,
573 &specs,
574 has_dev_units,
575 crate::core::resolver::features::ForceAllTargets::No,
576 dry_run,
577 )?;
578
579 let feature_opts = FeatureOpts::new_behavior(ResolveBehavior::V2, has_dev_units);
580 let v2_features = FeatureResolver::resolve(
581 ws,
582 target_data,
583 &ws_resolve.targeted_resolve,
584 &ws_resolve.pkg_set,
585 &opts.compile_opts.cli_features,
586 &specs,
587 &opts.compile_opts.build_config.requested_kinds,
588 feature_opts,
589 )?;
590
591 let diffs = v2_features.compare_legacy(&ws_resolve.resolved_features);
592 Ok((ws_resolve, diffs))
593 };
594 let (_, without_dev_diffs) = resolve_differences(HasDevUnits::No)?;
595 let (ws_resolve, mut with_dev_diffs) = resolve_differences(HasDevUnits::Yes)?;
596 if without_dev_diffs.is_empty() && with_dev_diffs.is_empty() {
597 return Ok(());
599 }
600 with_dev_diffs.retain(|k, vals| without_dev_diffs.get(k) != Some(vals));
602 let gctx = ws.gctx();
603 gctx.shell().note(
604 "Switching to Edition 2021 will enable the use of the version 2 feature resolver in Cargo.",
605 )?;
606 drop_eprintln!(
607 gctx,
608 "This may cause some dependencies to be built with fewer features enabled than previously."
609 );
610 drop_eprintln!(
611 gctx,
612 "More information about the resolver changes may be found \
613 at https://doc.rust-lang.org/nightly/edition-guide/rust-2021/default-cargo-resolver.html"
614 );
615 drop_eprintln!(
616 gctx,
617 "When building the following dependencies, \
618 the given features will no longer be used:\n"
619 );
620 let show_diffs = |differences: DiffMap| {
621 for ((pkg_id, features_for), removed) in differences {
622 drop_eprint!(gctx, " {}", pkg_id);
623 if let FeaturesFor::HostDep = features_for {
624 drop_eprint!(gctx, " (as host dependency)");
625 }
626 drop_eprint!(gctx, " removed features: ");
627 let joined: Vec<_> = removed.iter().map(|s| s.as_str()).collect();
628 drop_eprintln!(gctx, "{}", joined.join(", "));
629 }
630 drop_eprint!(gctx, "\n");
631 };
632 if !without_dev_diffs.is_empty() {
633 show_diffs(without_dev_diffs);
634 }
635 if !with_dev_diffs.is_empty() {
636 drop_eprintln!(
637 gctx,
638 "The following differences only apply when building with dev-dependencies:\n"
639 );
640 show_diffs(with_dev_diffs);
641 }
642 report_maybe_diesel(gctx, &ws_resolve.targeted_resolve)?;
643 Ok(())
644}
645
646fn report_maybe_diesel(gctx: &GlobalContext, resolve: &Resolve) -> CargoResult<()> {
647 fn is_broken_diesel(pid: PackageId) -> bool {
648 pid.name() == "diesel" && pid.version() < &Version::new(1, 4, 8)
649 }
650
651 fn is_broken_diesel_migration(pid: PackageId) -> bool {
652 pid.name() == "diesel_migrations" && pid.version().major <= 1
653 }
654
655 if resolve.iter().any(is_broken_diesel) && resolve.iter().any(is_broken_diesel_migration) {
656 gctx.shell().note(
657 "\
658This project appears to use both diesel and diesel_migrations. These packages have
659a known issue where the build may fail due to the version 2 resolver preventing
660feature unification between those two packages. Please update to at least diesel 1.4.8
661to prevent this issue from happening.
662",
663 )?;
664 }
665 Ok(())
666}
667
668pub fn fix_get_proxy_lock_addr() -> Option<String> {
673 #[allow(clippy::disallowed_methods)]
676 env::var(FIX_ENV_INTERNAL).ok()
677}
678
679pub fn fix_exec_rustc(gctx: &GlobalContext, lock_addr: &str) -> CargoResult<()> {
688 let args = FixArgs::get()?;
689 trace!("cargo-fix as rustc got file {:?}", args.file);
690
691 let workspace_rustc = gctx
692 .get_env("RUSTC_WORKSPACE_WRAPPER")
693 .map(PathBuf::from)
694 .ok();
695 let mut rustc = ProcessBuilder::new(&args.rustc).wrapped(workspace_rustc.as_ref());
696 rustc.retry_with_argfile(true);
697 rustc.env_remove(FIX_ENV_INTERNAL);
698 args.apply(&mut rustc);
699 if let Some(client) = gctx.jobserver_from_env() {
702 rustc.inherit_jobserver(client);
703 }
704
705 trace!("start rustfixing {:?}", args.file);
706 let fixes = rustfix_crate(&lock_addr, &rustc, &args.file, &args, gctx)?;
707
708 if fixes.last_output.status.success() {
709 for (path, file) in fixes.files.iter() {
710 Message::Fixed {
711 file: path.clone(),
712 fixes: file.fixes_applied,
713 }
714 .post(gctx)?;
715 }
716 emit_output(&fixes.last_output)?;
718 return Ok(());
719 }
720
721 let allow_broken_code = gctx.get_env_os(BROKEN_CODE_ENV_INTERNAL).is_some();
722
723 if !allow_broken_code {
727 for (path, file) in fixes.files.iter() {
728 debug!("reverting {:?} due to errors", path);
729 paths::write(path, &file.original_code)?;
730 }
731 }
732
733 if fixes.files.is_empty() {
739 emit_output(&fixes.last_output)?;
741 exit_with(fixes.last_output.status);
742 } else {
743 let krate = {
744 let mut iter = rustc.get_args();
745 let mut krate = None;
746 while let Some(arg) = iter.next() {
747 if arg == "--crate-name" {
748 krate = iter.next().and_then(|s| s.to_owned().into_string().ok());
749 }
750 }
751 krate
752 };
753 log_failed_fix(
754 gctx,
755 krate,
756 &fixes.last_output.stderr,
757 fixes.last_output.status,
758 )?;
759 emit_output(&fixes.first_output)?;
763 exit_with(fixes.first_output.status);
767 }
768}
769
770fn emit_output(output: &Output) -> CargoResult<()> {
771 std::io::stderr().write_all(&output.stderr)?;
775 std::io::stdout().write_all(&output.stdout)?;
776 Ok(())
777}
778
779struct FixedCrate {
780 files: HashMap<String, FixedFile>,
782 first_output: Output,
788 last_output: Output,
793}
794
795#[derive(Debug)]
796struct FixedFile {
797 errors_applying_fixes: Vec<String>,
798 fixes_applied: u32,
799 original_code: String,
800}
801
802fn rustfix_crate(
807 lock_addr: &str,
808 rustc: &ProcessBuilder,
809 filename: &Path,
810 args: &FixArgs,
811 gctx: &GlobalContext,
812) -> CargoResult<FixedCrate> {
813 let _lock = LockServerClient::lock(&lock_addr.parse()?, "global")?;
823
824 let mut files = HashMap::new();
826
827 if !args.can_run_rustfix(gctx)? {
828 debug!("can't fix {filename:?}, running rustc: {rustc}");
832 let last_output = rustc.output()?;
833 let fixes = FixedCrate {
834 files,
835 first_output: last_output.clone(),
836 last_output,
837 };
838 return Ok(fixes);
839 }
840
841 let max_iterations = gctx
875 .get_env("CARGO_FIX_MAX_RETRIES")
876 .ok()
877 .and_then(|n| n.parse().ok())
878 .unwrap_or(4);
879 let mut last_output;
880 let mut last_made_changes;
881 let mut first_output = None;
882 let mut current_iteration = 0;
883 loop {
884 for file in files.values_mut() {
885 file.errors_applying_fixes.clear();
887 }
888 (last_output, last_made_changes) =
889 rustfix_and_fix(&mut files, rustc, filename, args, gctx)?;
890 if current_iteration == 0 {
891 first_output = Some(last_output.clone());
892 }
893 let mut progress_yet_to_be_made = false;
894 for (path, file) in files.iter_mut() {
895 if file.errors_applying_fixes.is_empty() {
896 continue;
897 }
898 debug!("had rustfix apply errors in {path:?} {file:?}");
899 if last_made_changes {
903 progress_yet_to_be_made = true;
904 }
905 }
906 if !progress_yet_to_be_made {
907 break;
908 }
909 current_iteration += 1;
910 if current_iteration >= max_iterations {
911 break;
912 }
913 }
914 if last_made_changes {
915 debug!("calling rustc one last time for final results: {rustc}");
916 last_output = rustc.output()?;
917 }
918
919 for (path, file) in files.iter_mut() {
922 for error in file.errors_applying_fixes.drain(..) {
923 Message::ReplaceFailed {
924 file: path.clone(),
925 message: error,
926 }
927 .post(gctx)?;
928 }
929 }
930
931 Ok(FixedCrate {
932 files,
933 first_output: first_output.expect("at least one iteration"),
934 last_output,
935 })
936}
937
938fn rustfix_and_fix(
943 files: &mut HashMap<String, FixedFile>,
944 rustc: &ProcessBuilder,
945 filename: &Path,
946 args: &FixArgs,
947 gctx: &GlobalContext,
948) -> CargoResult<(Output, bool)> {
949 let only = HashSet::new();
952
953 debug!("calling rustc to collect suggestions and validate previous fixes: {rustc}");
954 let output = rustc.output()?;
955
956 if !output.status.success() && gctx.get_env_os(BROKEN_CODE_ENV_INTERNAL).is_none() {
962 debug!(
963 "rustfixing `{:?}` failed, rustc exited with {:?}",
964 filename,
965 output.status.code()
966 );
967 return Ok((output, false));
968 }
969
970 let fix_mode = gctx
971 .get_env_os("__CARGO_FIX_YOLO")
972 .map(|_| rustfix::Filter::Everything)
973 .unwrap_or(rustfix::Filter::MachineApplicableOnly);
974
975 let stderr = str::from_utf8(&output.stderr).context("failed to parse rustc stderr as UTF-8")?;
978
979 let suggestions = stderr
980 .lines()
981 .filter(|x| !x.is_empty())
982 .inspect(|y| trace!("line: {}", y))
983 .filter_map(|line| serde_json::from_str::<Diagnostic>(line).ok())
985 .filter_map(|diag| rustfix::collect_suggestions(&diag, &only, fix_mode));
987
988 let mut file_map = HashMap::new();
990 let mut num_suggestion = 0;
991 let home_path = gctx.home().as_path_unlocked();
993 for suggestion in suggestions {
994 trace!("suggestion");
995 let file_names = suggestion
999 .solutions
1000 .iter()
1001 .flat_map(|s| s.replacements.iter())
1002 .map(|r| &r.snippet.file_name);
1003
1004 let file_name = if let Some(file_name) = file_names.clone().next() {
1005 file_name.clone()
1006 } else {
1007 trace!("rejecting as it has no solutions {:?}", suggestion);
1008 continue;
1009 };
1010
1011 let file_path = Path::new(&file_name);
1012 if file_path.starts_with(home_path) {
1014 continue;
1015 }
1016 if let Some(sysroot) = args.sysroot.as_deref() {
1018 if file_path.starts_with(sysroot) {
1019 continue;
1020 }
1021 }
1022
1023 if !file_names.clone().all(|f| f == &file_name) {
1024 trace!("rejecting as it changes multiple files: {:?}", suggestion);
1025 continue;
1026 }
1027
1028 trace!("adding suggestion for {:?}: {:?}", file_name, suggestion);
1029 file_map
1030 .entry(file_name)
1031 .or_insert_with(Vec::new)
1032 .push(suggestion);
1033 num_suggestion += 1;
1034 }
1035
1036 debug!(
1037 "collected {} suggestions for `{}`",
1038 num_suggestion,
1039 filename.display(),
1040 );
1041
1042 let mut made_changes = false;
1043 for (file, suggestions) in file_map {
1044 let code = match paths::read(file.as_ref()) {
1048 Ok(s) => s,
1049 Err(e) => {
1050 warn!("failed to read `{}`: {}", file, e);
1051 continue;
1052 }
1053 };
1054 let num_suggestions = suggestions.len();
1055 debug!("applying {} fixes to {}", num_suggestions, file);
1056
1057 let fixed_file = files.entry(file.clone()).or_insert_with(|| FixedFile {
1062 errors_applying_fixes: Vec::new(),
1063 fixes_applied: 0,
1064 original_code: code.clone(),
1065 });
1066 let mut fixed = CodeFix::new(&code);
1067
1068 for suggestion in suggestions.iter().rev() {
1069 match fixed.apply(suggestion) {
1077 Ok(()) => fixed_file.fixes_applied += 1,
1078 Err(rustfix::Error::AlreadyReplaced {
1079 is_identical: true, ..
1080 }) => continue,
1081 Err(e) => fixed_file.errors_applying_fixes.push(e.to_string()),
1082 }
1083 }
1084 if fixed.modified() {
1085 made_changes = true;
1086 let new_code = fixed.finish()?;
1087 paths::write(&file, new_code)?;
1088 }
1089 }
1090
1091 Ok((output, made_changes))
1092}
1093
1094fn exit_with(status: ExitStatus) -> ! {
1095 #[cfg(unix)]
1096 {
1097 use std::os::unix::prelude::*;
1098 if let Some(signal) = status.signal() {
1099 drop(writeln!(
1100 std::io::stderr().lock(),
1101 "child failed with signal `{}`",
1102 signal
1103 ));
1104 process::exit(2);
1105 }
1106 }
1107 process::exit(status.code().unwrap_or(3));
1108}
1109
1110fn log_failed_fix(
1111 gctx: &GlobalContext,
1112 krate: Option<String>,
1113 stderr: &[u8],
1114 status: ExitStatus,
1115) -> CargoResult<()> {
1116 let stderr = str::from_utf8(stderr).context("failed to parse rustc stderr as utf-8")?;
1117
1118 let diagnostics = stderr
1119 .lines()
1120 .filter(|x| !x.is_empty())
1121 .filter_map(|line| serde_json::from_str::<Diagnostic>(line).ok());
1122 let mut files = BTreeSet::new();
1123 let mut errors = Vec::new();
1124 for diagnostic in diagnostics {
1125 errors.push(diagnostic.rendered.unwrap_or(diagnostic.message));
1126 for span in diagnostic.spans.into_iter() {
1127 files.insert(span.file_name);
1128 }
1129 }
1130 errors.extend(
1132 stderr
1133 .lines()
1134 .filter(|x| !x.starts_with('{'))
1135 .map(|x| x.to_string()),
1136 );
1137
1138 let files = files.into_iter().collect();
1139 let abnormal_exit = if status.code().map_or(false, is_simple_exit_code) {
1140 None
1141 } else {
1142 Some(exit_status_to_string(status))
1143 };
1144 Message::FixFailed {
1145 files,
1146 krate,
1147 errors,
1148 abnormal_exit,
1149 }
1150 .post(gctx)?;
1151
1152 Ok(())
1153}
1154
1155struct FixArgs {
1158 file: PathBuf,
1160 prepare_for_edition: Option<Edition>,
1163 idioms: bool,
1165 enabled_edition: Option<Edition>,
1169 other: Vec<OsString>,
1172 rustc: PathBuf,
1174 sysroot: Option<PathBuf>,
1176}
1177
1178impl FixArgs {
1179 fn get() -> CargoResult<FixArgs> {
1180 Self::from_args(env::args_os())
1181 }
1182
1183 fn from_args(argv: impl IntoIterator<Item = OsString>) -> CargoResult<Self> {
1185 let mut argv = argv.into_iter();
1186 let mut rustc = argv
1187 .nth(1)
1188 .map(PathBuf::from)
1189 .ok_or_else(|| anyhow::anyhow!("expected rustc or `@path` as first argument"))?;
1190 let mut file = None;
1191 let mut enabled_edition = None;
1192 let mut other = Vec::new();
1193
1194 let mut handle_arg = |arg: OsString| -> CargoResult<()> {
1195 let path = PathBuf::from(arg);
1196 if path.extension().and_then(|s| s.to_str()) == Some("rs") && path.exists() {
1197 file = Some(path);
1198 return Ok(());
1199 }
1200 if let Some(s) = path.to_str() {
1201 if let Some(edition) = s.strip_prefix("--edition=") {
1202 enabled_edition = Some(edition.parse()?);
1203 return Ok(());
1204 }
1205 }
1206 other.push(path.into());
1207 Ok(())
1208 };
1209
1210 if let Some(argfile_path) = rustc.to_str().unwrap_or_default().strip_prefix("@") {
1211 if argv.next().is_some() {
1214 bail!("argfile `@path` cannot be combined with other arguments");
1215 }
1216 let contents = fs::read_to_string(argfile_path)
1217 .with_context(|| format!("failed to read argfile at `{argfile_path}`"))?;
1218 let mut iter = contents.lines().map(OsString::from);
1219 rustc = iter
1220 .next()
1221 .map(PathBuf::from)
1222 .ok_or_else(|| anyhow::anyhow!("expected rustc as first argument"))?;
1223 for arg in iter {
1224 handle_arg(arg)?;
1225 }
1226 } else {
1227 for arg in argv {
1228 handle_arg(arg)?;
1229 }
1230 }
1231
1232 let file = file.ok_or_else(|| anyhow::anyhow!("could not find .rs file in rustc args"))?;
1233 #[allow(clippy::disallowed_methods)]
1236 let idioms = env::var(IDIOMS_ENV_INTERNAL).is_ok();
1237
1238 #[allow(clippy::disallowed_methods)]
1241 let prepare_for_edition = env::var(EDITION_ENV_INTERNAL).ok().map(|v| {
1242 let enabled_edition = enabled_edition.unwrap_or(Edition::Edition2015);
1243 let mode = EditionFixMode::from_str(&v);
1244 mode.next_edition(enabled_edition)
1245 });
1246
1247 #[allow(clippy::disallowed_methods)]
1250 let sysroot = env::var_os(SYSROOT_INTERNAL).map(PathBuf::from);
1251
1252 Ok(FixArgs {
1253 file,
1254 prepare_for_edition,
1255 idioms,
1256 enabled_edition,
1257 other,
1258 rustc,
1259 sysroot,
1260 })
1261 }
1262
1263 fn apply(&self, cmd: &mut ProcessBuilder) {
1264 cmd.arg(&self.file);
1265 cmd.args(&self.other);
1266 if self.prepare_for_edition.is_some() {
1267 cmd.arg("--cap-lints=allow");
1272 } else {
1273 cmd.arg("--cap-lints=warn");
1275 }
1276 if let Some(edition) = self.enabled_edition {
1277 cmd.arg("--edition").arg(edition.to_string());
1278 if self.idioms && edition.supports_idiom_lint() {
1279 cmd.arg(format!("-Wrust-{}-idioms", edition));
1280 }
1281 }
1282
1283 if let Some(edition) = self.prepare_for_edition {
1284 edition.force_warn_arg(cmd);
1285 }
1286 }
1287
1288 fn can_run_rustfix(&self, gctx: &GlobalContext) -> CargoResult<bool> {
1291 let Some(to_edition) = self.prepare_for_edition else {
1292 return Message::Fixing {
1293 file: self.file.display().to_string(),
1294 }
1295 .post(gctx)
1296 .and(Ok(true));
1297 };
1298 if !to_edition.is_stable() && !gctx.nightly_features_allowed {
1309 let message = format!(
1310 "`{file}` is on the latest edition, but trying to \
1311 migrate to edition {to_edition}.\n\
1312 Edition {to_edition} is unstable and not allowed in \
1313 this release, consider trying the nightly release channel.",
1314 file = self.file.display(),
1315 to_edition = to_edition
1316 );
1317 return Message::EditionAlreadyEnabled {
1318 message,
1319 edition: to_edition.previous().unwrap(),
1320 }
1321 .post(gctx)
1322 .and(Ok(false)); }
1324 let from_edition = self.enabled_edition.unwrap_or(Edition::Edition2015);
1325 if from_edition == to_edition {
1326 let message = format!(
1327 "`{}` is already on the latest edition ({}), \
1328 unable to migrate further",
1329 self.file.display(),
1330 to_edition
1331 );
1332 Message::EditionAlreadyEnabled {
1333 message,
1334 edition: to_edition,
1335 }
1336 .post(gctx)
1337 } else {
1338 Message::Migrating {
1339 file: self.file.display().to_string(),
1340 from_edition,
1341 to_edition,
1342 }
1343 .post(gctx)
1344 }
1345 .and(Ok(true))
1346 }
1347}
1348
1349#[cfg(test)]
1350mod tests {
1351 use super::FixArgs;
1352 use std::ffi::OsString;
1353 use std::io::Write as _;
1354 use std::path::PathBuf;
1355
1356 #[test]
1357 fn get_fix_args_from_argfile() {
1358 let mut temp = tempfile::Builder::new().tempfile().unwrap();
1359 let main_rs = tempfile::Builder::new().suffix(".rs").tempfile().unwrap();
1360
1361 let content = format!("/path/to/rustc\n{}\nfoobar\n", main_rs.path().display());
1362 temp.write_all(content.as_bytes()).unwrap();
1363
1364 let argfile = format!("@{}", temp.path().display());
1365 let args = ["cargo", &argfile];
1366 let fix_args = FixArgs::from_args(args.map(|x| x.into())).unwrap();
1367 assert_eq!(fix_args.rustc, PathBuf::from("/path/to/rustc"));
1368 assert_eq!(fix_args.file, main_rs.path());
1369 assert_eq!(fix_args.other, vec![OsString::from("foobar")]);
1370 }
1371
1372 #[test]
1373 fn get_fix_args_from_argfile_with_extra_arg() {
1374 let mut temp = tempfile::Builder::new().tempfile().unwrap();
1375 let main_rs = tempfile::Builder::new().suffix(".rs").tempfile().unwrap();
1376
1377 let content = format!("/path/to/rustc\n{}\nfoobar\n", main_rs.path().display());
1378 temp.write_all(content.as_bytes()).unwrap();
1379
1380 let argfile = format!("@{}", temp.path().display());
1381 let args = ["cargo", &argfile, "boo!"];
1382 match FixArgs::from_args(args.map(|x| x.into())) {
1383 Err(e) => assert_eq!(
1384 e.to_string(),
1385 "argfile `@path` cannot be combined with other arguments"
1386 ),
1387 Ok(_) => panic!("should fail"),
1388 }
1389 }
1390}