Avoid cloning source code multiple times

crates/ruff/src/jupyter/notebook.rs

@@ -132,8 +132,8 @@ impl Notebook {
     }
 
     /// Read the Jupyter Notebook from its JSON string.
-    pub fn from_contents(contents: &str) -> Result<Self, Box<Diagnostic>> {
-        Self::from_reader(Cursor::new(contents))
+    pub fn from_source_code(source_code: &str) -> Result<Self, Box<Diagnostic>> {
+        Self::from_reader(Cursor::new(source_code))
     }
 
     /// Read a Jupyter Notebook from a [`Read`] implementor.
@@ -404,7 +404,7 @@ impl Notebook {
     /// Return the notebook content.
     ///
     /// This is the concatenation of all Python code cells.
-    pub(crate) fn content(&self) -> &str {
+    pub fn content(&self) -> &str {
         &self.content
     }
 

crates/ruff/src/source_kind.rs

@@ -2,19 +2,11 @@ use crate::jupyter::Notebook;
 
 #[derive(Clone, Debug, PartialEq, is_macro::Is)]
 pub enum SourceKind {
-    Python(String),
+    Python,
     Jupyter(Notebook),
 }
 
 impl SourceKind {
-    /// Return the source content.
-    pub fn content(&self) -> &str {
-        match self {
-            SourceKind::Python(content) => content,
-            SourceKind::Jupyter(notebook) => notebook.content(),
-        }
-    }
-
     /// Return the [`Notebook`] if the source kind is [`SourceKind::Jupyter`].
     pub fn notebook(&self) -> Option<&Notebook> {
         if let Self::Jupyter(notebook) = self {

crates/ruff/src/test.rs

@@ -6,14 +6,13 @@ use std::path::Path;
 #[cfg(not(fuzzing))]
 use anyhow::Result;
 use itertools::Itertools;
-use ruff_python_parser::lexer::LexResult;
-
 use rustc_hash::FxHashMap;
 
 use ruff_diagnostics::{AutofixKind, Diagnostic};
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
+use ruff_python_parser::lexer::LexResult;
 use ruff_python_parser::AsMode;
 use ruff_python_trivia::textwrap::dedent;
 use ruff_source_file::{Locator, SourceFileBuilder};
@@ -53,7 +52,8 @@ pub(crate) fn test_path(path: impl AsRef<Path>, settings: &Settings) -> Result<V
     let path = test_resource_path("fixtures").join(path);
     let contents = std::fs::read_to_string(&path)?;
     Ok(test_contents(
-        &mut SourceKind::Python(contents),
+        &contents,
+        &mut SourceKind::Python,
         &path,
         settings,
     ))
@@ -65,9 +65,11 @@ pub(crate) fn test_notebook_path(
     expected: impl AsRef<Path>,
     settings: &Settings,
 ) -> Result<(Vec<Message>, SourceKind, SourceKind)> {
-    let mut source_kind = SourceKind::Jupyter(read_jupyter_notebook(path.as_ref())?);
+    let notebook = read_jupyter_notebook(path.as_ref())?;
+    let contents = notebook.content().to_string();
+    let mut source_kind = SourceKind::Jupyter(notebook);
     let original_source_kind = source_kind.clone();
-    let messages = test_contents(&mut source_kind, path.as_ref(), settings);
+    let messages = test_contents(&contents, &mut source_kind, path.as_ref(), settings);
     let expected_notebook = read_jupyter_notebook(expected.as_ref())?;
     if let SourceKind::Jupyter(notebook) = &source_kind {
         assert_eq!(notebook.cell_offsets(), expected_notebook.cell_offsets());
@@ -81,11 +83,7 @@ pub(crate) fn test_notebook_path(
 pub fn test_snippet(contents: &str, settings: &Settings) -> Vec<Message> {
     let path = Path::new("<filename>");
     let contents = dedent(contents);
-    test_contents(
-        &mut SourceKind::Python(contents.to_string()),
-        path,
-        settings,
-    )
+    test_contents(&contents, &mut SourceKind::Python, path, settings)
 }
 
 thread_local! {
@@ -102,11 +100,15 @@ pub(crate) fn max_iterations() -> usize {
 
 /// A convenient wrapper around [`check_path`], that additionally
 /// asserts that autofixes converge after a fixed number of iterations.
-fn test_contents(source_kind: &mut SourceKind, path: &Path, settings: &Settings) -> Vec<Message> {
-    let contents = source_kind.content().to_string();
+fn test_contents(
+    contents: &str,
+    source_kind: &mut SourceKind,
+    path: &Path,
+    settings: &Settings,
+) -> Vec<Message> {
     let source_type = PySourceType::from(path);
-    let tokens: Vec<LexResult> = ruff_python_parser::tokenize(&contents, source_type.as_mode());
-    let locator = Locator::new(&contents);
+    let tokens: Vec<LexResult> = ruff_python_parser::tokenize(contents, source_type.as_mode());
+    let locator = Locator::new(contents);
     let stylist = Stylist::from_tokens(&tokens, &locator);
     let indexer = Indexer::from_tokens(&tokens, &locator);
     let directives = directives::extract_directives(
@@ -225,7 +227,7 @@ Source with applied fixes:
 
     let source_code = SourceFileBuilder::new(
         path.file_name().unwrap().to_string_lossy().as_ref(),
-        contents.as_str(),
+        contents,
     )
     .finish();