/// The non-lint diagnostics that can't be fixed or the diagnostics of files

/// that couldn't be fixed because ty failed to write the result back to disk,

/// or the file contains a syntax errors after fixing.

pub diagnostics: Vec<Diagnostic>,

/// The number of diagnostics that were fixed across all files.

pub count: usize,

db: &mut dyn Db,

diagnostics: Vec<Diagnostic>,

cancellation_token: &CancellationToken,

) -> Result<FixAllResults, Canceled> {

fix_all(

db,

diagnostics,

FixMode::Suppress,

cancellation_token,

Db::check_file,

)

db: &mut dyn Db,

diagnostics: Vec<Diagnostic>,

applicability: Applicability,

cancellation_token: &CancellationToken,

) -> Result<FixAllResults, Canceled> {

fix_all(

db,

diagnostics,

FixMode::ApplyFixes(applicability),

cancellation_token,

Db::check_file,

)

db: &mut dyn Db,

mut diagnostics: Vec<Diagnostic>,

fix_mode: FixMode,

cancellation_token: &CancellationToken,

check_file: F,

) -> Result<FixAllResults, Canceled>

F: Fn(&dyn Db, File) -> Vec<Diagnostic> + Sync,

let system = WritableSystem::dyn_clone(

db.system()

.as_writable()

.expect("System should be writable"),

);

let has_fixable = diagnostics

.iter()

.any(|diagnostic| fix_mode.is_fixable(diagnostic));

// Early return if there are no diagnostics that can be suppressed to avoid all the heavy work below.

if !has_fixable {

return Ok(FixAllResults {

diagnostics,

count: 0,

});

}

let mut by_file: BTreeMap<File, Vec<_>> = BTreeMap::new();

// Group the diagnostics by file, leave the file-agnostic diagnostics in `diagnostics`.

for diagnostic in diagnostics.extract_if(.., |diagnostic| diagnostic.primary_span().is_some()) {

let span = diagnostic

.primary_span()

.expect("should be set because `extract_if` only yields elements with a primary_span");

by_file

.entry(span.expect_ty_file())

.or_default()

.push(diagnostic);

}

// Identify all files with fixes and queue them for fixing.

let mut queue: Vec<(QueuedFile, Vec<ApplicableFix>)> = Vec::new();

let mut source_texts = SourceTexts::default();

for (&file, diagnostics) in &by_file {

let path = file.path(db);

let Some(path) = path.as_system_path() else {

tracing::debug!("Skipping read-only file `{path}`");

continue;

};

let python_file = db.program_file(file).python_file(db);

let parsed = parsed_module(db, python_file);

if parsed.load(db).has_syntax_errors() {

tracing::warn!("Skipping file `{path}` with syntax errors");

continue;

}

let fixes = fix_mode.fixes(db, python_file, diagnostics);

if fixes.is_empty() {

tracing::debug!("Skipping file `{path}` without applicable fixes.");

continue;

}

queue.push((QueuedFile::new(file, path, diagnostics), fixes));

}

// Try applying the fixes. Iterate at most `MAX_ITERATIONS` times.

let mut remaining_iterations = MAX_ITERATIONS;

let mut completed: Vec<FixedFile> = Vec::with_capacity(queue.len());

while !queue.is_empty() {

let is_last_iteration = remaining_iterations == 1;

let mut unstaged_fixes = Vec::with_capacity(queue.len());

for (file, fixes) in queue.drain(..) {

if cancellation_token.is_cancelled() {

source_texts.revert_all(db);

return Err(Canceled);

}

let staged_source = source_texts.staged(db, file.file);

let FixedCode {

source,

source_map,

applied_fixes,

} = apply_fixes(&staged_source, fixes);

let fixed_source = staged_source.with_text(source, &source_map);

source_texts.set_unstaged(db, file.file, fixed_source.clone());

unstaged_fixes.push((file, applied_fixes));

}

// Check if applying the files introduced any syntax errors, compute the remaining diagnostics and any new fixes.

// This is done outside the above loop so that it can run in parallel.

let check_results = recheck_files(

&*db,

unstaged_fixes,

fix_mode,

cancellation_token,

&check_file,

);

if cancellation_token.is_cancelled() {

source_texts.revert_all(db);

return Err(Canceled);

}

for result in check_results {

if cancellation_token.is_cancelled() {

source_texts.revert_all(db);

return Err(Canceled);

}

match result {

CheckResult::Checked { mut file, fixes } => {

source_texts.stage(file.file);

if fixes.is_empty() {

completed.push(file.into_fixed());

continue;

}

if is_last_iteration {

let diagnostic = create_too_many_iterations_diagnostics(

file.file,

fix_mode,

file.diagnostics(),

);

file.push_diagnostic(diagnostic);

completed.push(file.into_fixed());

continue;

}

// Requeue the file for another round of fixes.

queue.push((file, fixes));

}

CheckResult::SyntaxError {

mut file,

diagnostic,

} => {

// Reset the file's state to the last staged changes (or the original source text if this is the first iteration)

source_texts.reset_unstaged(db, file.file);

file.push_diagnostic(diagnostic);

completed.push(file.into_fixed());

}

}

}

if is_last_iteration {

break;

}

remaining_iterations -= 1;

}

// commit the changes: Write the changes to disk

let mut fix_count = 0;

for file in completed {

if cancellation_token.is_cancelled() {

source_texts.revert_all(db);

return Err(Canceled);

}

if let Some(fixed) = source_texts.uncommitted(file.file) {

if let Err(error) = write_changes(db, &*system, file.file, &file.path, fixed) {

// revert the source text back to its original content.

source_texts.revert(db, file.file);

// Writing failed, revert the source text override back to the file's original source.

let mut diagnostics = by_file.remove(&file.file).unwrap_or_default();

let mut diag = Diagnostic::new(

DiagnosticId::Io,

Severity::Error,

format_args!("Failed to write fixes to file: {error}"),

);

diag.annotate(Annotation::primary(Span::from(file.file)));

diagnostics.push(diag);

by_file.insert(file.file, diagnostics);

continue;

}

source_texts.commit(file.file);

}

fix_count += file.applied_fixes;

by_file.insert(file.file, file.remaining_diagnostics);

}

// Stitch the remaining diagnostics back together.

diagnostics.extend(by_file.into_values().flatten());

diagnostics.sort_by(|left, right| {

left.rendering_sort_key(db)

.cmp(&right.rendering_sort_key(db))

});

Ok(FixAllResults {

diagnostics,

count: fix_count,

})

db: &dyn Db,

file: File,

parsed: &ParsedModuleRef,

) -> Diagnostic {

let mut diag = Diagnostic::new(

DiagnosticId::InternalError,

Severity::Fatal,

format_args!("Applying fixes introduced a syntax error. Reverting changes."),

);

let mut file_annotation = Annotation::primary(Span::from(file));

file_annotation.hide_snippet(true);

diag.annotate(file_annotation);

let parse_diagnostics: Vec<_> = parsed

.errors()

.iter()

.map(|error| Diagnostic::invalid_syntax(Span::from(file), &error.error, error.location))

.collect();

diag.add_bug_sub_diagnostics("%5BFix%20error%5D");

let file_db: &dyn ruff_db::Db = db;

diag.info(format_args!(

"Introduced syntax errors:\n\n{}",

DisplayDiagnostics::new(

&file_db,

&DisplayDiagnosticConfig::new("ty"),

&parse_diagnostics

)

));

diag

file: File,

fix_mode: FixMode,

diagnostics: &[Diagnostic],

) -> Diagnostic {

let mut fixable_ids = diagnostics

.iter()

.filter(|diagnostic| fix_mode.is_fixable(diagnostic))

.map(|diagnostic| diagnostic.id().as_str())

.collect::<Vec<_>>();

fixable_ids.sort_unstable();

let codes = fixable_ids.join(", ");

let mut diag = Diagnostic::new(

DiagnosticId::InternalError,

Severity::Fatal,

format_args!("Fixes failed to converge after {MAX_ITERATIONS} iterations."),

);

let mut file_annotation = Annotation::primary(Span::from(file));

file_annotation.hide_snippet(true);

diag.annotate(file_annotation);

diag.add_bug_sub_diagnostics("%5BInfinite%20loop%5D");

diag.info(format_args!("Fixable diagnostics: {codes}"));

diag

/// Adds suppression comments for every suppressable diagnostic.

Suppress,

/// Applies the diagnostic's fixes that have at least the given applicability.

ApplyFixes(Applicability),

fn is_fixable(self, diagnostic: &Diagnostic) -> bool {

let Some(primary_span) = diagnostic.primary_span() else {

return false;

};

match self {

FixMode::Suppress => {

primary_span.range().is_some()

&& diagnostic

.id()

.as_lint()

.is_some_and(|name| !is_unused_ignore_comment_lint(name))

}

FixMode::ApplyFixes(applicability) => diagnostic.has_applicable_fix(applicability),

}

}

fn fixes(

self,

db: &dyn Db,

file: PythonFile<'_>,

file_diagnostics: &[Diagnostic],

) -> Vec<ApplicableFix> {

match self {

FixMode::Suppress => {

let suppressable_diagnostics: Vec<_> = file_diagnostics

.iter()

.filter_map(|diagnostic| {

let lint_id = diagnostic.id().as_lint()?;

// Don't suppress unused ignore comments.

if is_unused_ignore_comment_lint(lint_id) {

return None;

}

// We can't suppress diagnostics without a corresponding file or range.

let span = diagnostic.primary_span()?;

let range = span.range()?;

Some((lint_id, range))

})

.collect();

suppress_all(db, file, &suppressable_diagnostics)

.into_iter()

.map(

|SuppressFix {

fix,

suppressed_diagnostics,

}| ApplicableFix {

fix,

fixed_diagnostics: suppressed_diagnostics,

},

)

.collect()

}

FixMode::ApplyFixes(applicability) => file_diagnostics

.iter()

.filter(|diagnostic| diagnostic.has_applicable_fix(applicability))

.filter_map(|diagnostic| {

diagnostic.fix().cloned().map(|fix| ApplicableFix {

fix,

fixed_diagnostics: 1,

})

})

.collect(),

}

}

fix: Fix,

/// The number of diagnostics this fix resolves.

///

/// This is always 1 for `--fix`, but there are instances where `--add-ignore` can suppress

/// multiple diagnostics with a single suppression (fix).

///

/// In the following example, the two `invalid-argument-type` diagnostics can be suppressed (fixed)

/// by inserting a single suppression comment at the end of the call expression:

///

/// ```py

/// enumerate(0, "1")

/// # ^ expected iterable

/// # ^^^ expected int

/// ```

///

/// Gets fixed to:

///

/// ```py

/// enumerate(0, "1") # ty: ignore[invalid-argument-type]

/// ```

///

/// In which case `fixed_diagnostics` is 2.

fixed_diagnostics: usize,

db: &dyn Db,

system: &dyn WritableSystem,

file: File,

path: &SystemPath,

new_text: &SourceText,

) -> Result<(), WriteChangesError> {

let metadata = system.path_metadata(path)?;

if metadata.revision() != file.revision(db) {

return Err(WriteChangesError::FileWasModified);

}

system.write_file_bytes(path, &new_text.to_bytes())?;

Ok(())

#[error("failed to write changes to disk: {0}")]

Io(#[from] std::io::Error),

#[error("the file has been modified")]

FileWasModified,

let mut output = String::with_capacity(source.len());

let mut last_pos: Option<TextSize> = None;

let mut isolated: FxHashSet<u32> = FxHashSet::default();

let mut applied_edits: FxHashSet<&Edit> = FxHashSet::default();

let mut source_map = SourceMap::default();

fixes.sort_unstable_by_key(|fix| fix.fix.min_start());

let mut applied_fixes = 0usize;

for fix in &fixes {

let ApplicableFix {

fix,

fixed_diagnostics,

} = fix;

let mut edits = fix

.edits()

.iter()

.filter(|edit| !applied_edits.contains(edit))

.peekable();

// If the fix contains at least one new edit, enforce isolation and positional requirements.

if let Some(first) = edits.peek() {

// If this fix requires isolation, and we've already applied another fix in the

// same isolation group, skip it.

if let IsolationLevel::Group(id) = fix.isolation() {

if !isolated.insert(id) {

continue;

}

}

// If this fix overlaps with a fix we've already applied, skip it.

if last_pos.is_some_and(|last_pos| last_pos >= first.start()) {

continue;

}

}

for edit in edits {

// Add all contents from `last_pos` to `fix.location`.

let slice = &source[TextRange::new(last_pos.unwrap_or_default(), edit.start())];

output.push_str(slice);

// Add the start source marker for the patch.

source_map.push_start_marker(edit, output.text_len());

// Add the patch itself.

output.push_str(edit.content().unwrap_or_default());

// Add the end source marker for the added patch.

source_map.push_end_marker(edit, output.text_len());

// Track that the edit was applied.

last_pos = Some(edit.end());

}

applied_edits.extend(fix.edits());

applied_fixes += fixed_diagnostics;

}

// Add the remaining content.

let slice = &source[last_pos.unwrap_or_default().to_usize()..];

output.push_str(slice);

FixedCode {

source: output,

source_map,

applied_fixes,

}

/// Source map that allows mapping positions in the fixed code back to positions in the original

/// source code (useful for mapping fixed lines back to their original notebook cells).

source_map: SourceMap,

/// The fixed source code

source: String,

/// The number of fixes that were applied.

applied_fixes: usize,

/// Stores the original source text for each file that has outstanding writes.

originals: FxHashMap<File, SourceText>,

unstaged_changes: FxHashMap<File, SourceText>,

staged_changes: FxHashMap<File, SourceText>,

/// Returns the staged source text of `file`, ignoring any unstaged changes.

fn staged(&self, db: &dyn Db, file: File) -> SourceText {

if let Some(staged) = self.staged_changes.get(&file) {

staged.clone()

} else {

source_text(db, file)

}

}

/// Returns any uncommitted changes (staged or unstaged).

///

/// Returns `None` if there are no uncommitted changes.

fn uncommitted(&self, file: File) -> Option<&SourceText> {

self.unstaged_changes

.get(&file)

.or_else(|| self.staged_changes.get(&file))

}

/// Promotes any unstaged changes of `file` to staged.

///

/// This is a no-op if there are no unstaged changes.

fn stage(&mut self, file: File) {

let Some(changes) = self.unstaged_changes.remove(&file) else {

return;

};

self.staged_changes.insert(file, changes);

}

/// Sets unstaged changes for `file`.

fn set_unstaged(&mut self, db: &mut dyn Db, file: File, new_text: SourceText) {

self.originals

.entry(file)

.or_insert_with(|| source_text(db, file));

file.set_source_text_override(db).to(Some(new_text.clone()));

self.unstaged_changes.insert(file, new_text);

}

/// Reverts any unstaged changes and reverts the source text of `file` to

/// the last staged changed or its original content.

fn reset_unstaged(&mut self, db: &mut dyn Db, file: File) {

if self.unstaged_changes.remove(&file).is_none() {

return;

}

// Try to reset to the last staged changes

let source = if let Some(staged) = self.staged_changes.get(&file) {

staged

} else if let Some(original) = self.originals.get(&file) {

original

} else {

// File was never overridden, nothing to do

return;

};

file.set_source_text_override(db).to(Some(source.clone()));

}

/// Revert all files with a tracked override back to their original source text.

fn revert_all(self, db: &mut dyn Db) {

#[expect(

for (file, original) in self.originals {

file.set_source_text_override(db).to(Some(original));

}

}

/// Revert `file` back to its original source text.

///

/// ## Panics

/// If `file` has no override.

fn revert(&mut self, db: &mut dyn Db, file: File) {

let Some(original) = self.originals.remove(&file) else {

return;

};

file.set_source_text_override(db).to(Some(original));

}

/// Commits any staged changes.

fn commit(&mut self, file: File) {

self.staged_changes.remove(&file);

if !self.unstaged_changes.contains_key(&file) {

self.originals.remove(&file);

}

}

file: File,

path: SystemPathBuf,

/// The original diagnostics of the source text as on disk.

original_diagnostics: &'a [Diagnostic],

/// The new diagnostics for this after fixes were applied or `None` if it's still the original diagnostics.

diagnostics: Option<Vec<Diagnostic>>,

applied_fixes: usize,

fn new(file: File, path: &SystemPath, original_diagnostics: &'a [Diagnostic]) -> Self {

Self {

file,

path: path.to_path_buf(),

original_diagnostics,

diagnostics: None,

applied_fixes: 0,

}

}

fn diagnostics(&self) -> &[Diagnostic] {

match &self.diagnostics {

None => self.original_diagnostics,

Some(diagnostics) => diagnostics,

}

}

fn push_diagnostic(&mut self, diagnostic: Diagnostic) {

let diagnostics = self

.diagnostics

.get_or_insert_with(|| self.original_diagnostics.to_vec());

diagnostics.push(diagnostic);

}

fn into_fixed(self) -> FixedFile {

FixedFile {

file: self.file,

path: self.path,

remaining_diagnostics: self.diagnostics.unwrap_or_default(),

applied_fixes: self.applied_fixes,

}

}

file: File,

path: SystemPathBuf,

remaining_diagnostics: Vec<Diagnostic>,

applied_fixes: usize,

/// The unstaged fixes introduced a syntax error.

SyntaxError {

diagnostic: Diagnostic,

file: QueuedFile<'a>,

},

/// The fixes were successfully applied without introducing any syntax errors.

Checked {

file: QueuedFile<'a>,

/// The fixes for the next round (may be empty)

fixes: Vec<ApplicableFix>,

},

db: &dyn Db,

changes: Vec<(QueuedFile<'a>, usize)>,

fix_mode: FixMode,

cancellation_token: &CancellationToken,

check_file: &F,

) -> Vec<CheckResult<'a>>

F: Fn(&dyn Db, File) -> Vec<Diagnostic> + Sync,

let results = Mutex::new(Vec::with_capacity(changes.len()));

{

let outcomes = &results;

let db = db.dyn_clone();

rayon::scope(move |scope| {

for (mut file, applied_fixes) in changes {

let db = db.dyn_clone();

scope.spawn(move |_| {

if cancellation_token.is_cancelled() {

return;

}

let db = &*db;

let python_file = db.program_file(file.file).python_file(db);

let parsed = parsed_module(db, python_file);

let parsed = parsed.load(db);

let result = if parsed.has_syntax_errors() {

let diagnostic =

create_fix_introduced_syntax_error_diagnostic(db, file.file, &parsed);

CheckResult::SyntaxError { diagnostic, file }

} else {

let diagnostics = check_file(db, file.file);

let fixes = fix_mode.fixes(db, python_file, &diagnostics);

file.applied_fixes += applied_fixes;

file.diagnostics = Some(diagnostics);

CheckResult::Checked { file, fixes }

};

outcomes.lock().unwrap().push(result);

});

}

});

}

results.into_inner().unwrap()

use insta::assert_snapshot;

use ruff_db::cancellation::CancellationTokenSource;

use ruff_db::diagnostic::{

Annotation, Diagnostic, DiagnosticId, DisplayDiagnosticConfig, DisplayDiagnostics,

Severity, Span,

};

use ruff_db::files::{File, system_path_to_file};

use ruff_db::parsed::parsed_module;

use ruff_db::source::source_text;

use ruff_db::system::SystemPath;

use ruff_diagnostics::{Applicability, Edit, Fix};

use ruff_text_size::{TextLen as _, TextRange, TextSize};

use rustc_hash::FxHashMap;

use std::collections::hash_map::Entry;

use std::hash::{DefaultHasher, Hash, Hasher};

use super::suppress_all_diagnostics;

use crate::Db;

use crate::db::tests::TestDbBuilder;

use crate::fixes::{FixMode, fix_all};

use crate::is_unused_ignore_comment_lint;

#[test]

fn simple_suppression() {

assert_snapshot!(

suppress_all_in(r#"

),

@"

}

#[test]

fn multiple_suppressions_same_code() {

assert_snapshot!(

suppress_all_in(r#"

),

@"

}

#[test]

fn multiple_suppressions_different_codes() {

assert_snapshot!(

suppress_all_in(r#"

),

@"

}

#[test]

fn dont_fix_unused_ignore() {

assert_snapshot!(

suppress_all_in(r#"

),

@"

}

#[test]

fn dont_fix_files_containing_syntax_errors() {

assert_snapshot!(

suppress_all_in(r#"

),

@"

}

#[test]

fn arguments() {

assert_snapshot!(

suppress_all_in(r#"

),

@r#"

}

// A same-code suppression inserted at the end of a narrower multiline range can land on the

// start line of a wider multiline range, which makes the wider range's own suppression

// redundant.

#[test]

fn same_code_multiline_suppressions_with_different_ranges_can_become_redundant() {

assert_snapshot!(

suppress_all_in(r#"