Catch panics in formatter (#7377)

## Summary

This PR ensures that we catch and render panics in the formatter
identically to other kinds of errors. It also improves the consistency
in error rendering throughout and makes a few stylistic changes to the
messages.

Closes https://github.com/astral-sh/ruff/issues/7247.

## Test Plan

I created a file `foo.py` with a syntax error, and a file `bar.py` with
an intentional panic.

<img width="1624" alt="Screen Shot 2023-09-13 at 10 25 22 PM"
src="605c2839-ad02-4376-a2e9-d5a593ab660f">

<img width="1624" alt="Screen Shot 2023-09-13 at 10 25 24 PM"
src="b1381909-157c-48cb-9630-d0bbfcb1b640">

crates/ruff_cli/src/commands/check.rs

@@ -211,16 +211,16 @@ fn lint_path(
     match result {
         Ok(inner) => inner,
         Err(error) => {
-            let message = r#"This indicates a bug in `ruff`. If you could open an issue at:
+            let message = r#"This indicates a bug in Ruff. If you could open an issue at:
 
-https://github.com/astral-sh/ruff/issues/new?title=%5BLinter%20panic%5D
+    https://github.com/astral-sh/ruff/issues/new?title=%5BLinter%20panic%5D
 
-with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
+...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
 "#;
 
-            warn!(
+            error!(
                 "{}{}{} {message}\n{error}",
-                "Linting panicked ".bold(),
+                "Panicked while linting ".bold(),
                 fs::relativize_path(path).bold(),
                 ":".bold()
             );

crates/ruff_cli/src/commands/format.rs

@@ -6,6 +6,7 @@ use std::time::Instant;
 
 use anyhow::Result;
 use colored::Colorize;
+use log::error;
 use rayon::iter::Either::{Left, Right};
 use rayon::iter::{IntoParallelIterator, ParallelIterator};
 use thiserror::Error;
@@ -22,6 +23,7 @@ use ruff_source_file::{find_newline, LineEnding};
 use ruff_workspace::resolver::python_files_in_path;
 
 use crate::args::{FormatArguments, Overrides};
+use crate::panic::{catch_unwind, PanicError};
 use crate::resolve::resolve;
 use crate::ExitStatus;
 
@@ -85,7 +87,13 @@ pub(crate) fn format(
                         .with_line_width(LineWidth::from(NonZeroU16::from(line_length)))
                         .with_preview(preview);
                     debug!("Formatting {} with {:?}", path.display(), options);
-                    Some(format_path(path, options, mode))
+
+                    Some(match catch_unwind(|| format_path(path, options, mode)) {
+                        Ok(inner) => inner,
+                        Err(error) => {
+                            Err(FormatCommandError::Panic(Some(path.to_path_buf()), error))
+                        }
+                    })
                 }
                 Err(err) => Some(Err(FormatCommandError::Ignore(err))),
             }
@@ -95,22 +103,20 @@ pub(crate) fn format(
             Err(err) => Right(err),
         });
     let duration = start.elapsed();
+
     debug!(
         "Formatted {} files in {:.2?}",
         results.len() + errors.len(),
         duration
     );
 
-    let summary = FormatResultSummary::new(results, mode);
-
     // Report on any errors.
-    if !errors.is_empty() {
-        warn!("Encountered {} errors while formatting:", errors.len());
-        for error in &errors {
-            warn!("{error}");
-        }
+    for error in &errors {
+        error!("{error}");
     }
 
+    let summary = FormatResultSummary::new(results, mode);
+
     // Report on the formatting changes.
     if log_level >= LogLevel::Default {
         #[allow(clippy::print_stdout)]
@@ -255,6 +261,7 @@ pub(crate) enum FormatCommandError {
     Read(Option<PathBuf>, io::Error),
     Write(Option<PathBuf>, io::Error),
     FormatModule(Option<PathBuf>, FormatModuleError),
+    Panic(Option<PathBuf>, PanicError),
 }
 
 impl Display for FormatCommandError {
@@ -320,6 +327,29 @@ impl Display for FormatCommandError {
                     write!(f, "{}{} {err}", "Failed to format".bold(), ":".bold())
                 }
             }
+            Self::Panic(path, err) => {
+                let message = r#"This indicates a bug in Ruff. If you could open an issue at:
+
+    https://github.com/astral-sh/ruff/issues/new?title=%5BFormatter%20panic%5D
+
+...with the relevant file contents, the `pyproject.toml` settings, and the following stack trace, we'd be very appreciative!
+"#;
+                if let Some(path) = path {
+                    write!(
+                        f,
+                        "{}{}{} {message}\n{err}",
+                        "Panicked while formatting ".bold(),
+                        fs::relativize_path(path).bold(),
+                        ":".bold()
+                    )
+                } else {
+                    write!(
+                        f,
+                        "{} {message}\n{err}",
+                        "Panicked while formatting.".bold()
+                    )
+                }
+            }
         }
     }
 }