Extract LineIndex independent methods from Locator

crates/red_knot_test/src/assertion.rs

@@ -40,7 +40,7 @@ use ruff_db::files::File;
 use ruff_db::parsed::parsed_module;
 use ruff_db::source::{line_index, source_text, SourceText};
 use ruff_python_trivia::CommentRanges;
-use ruff_source_file::{LineIndex, Locator, OneIndexed};
+use ruff_source_file::{LineIndex, OneIndexed};
 use ruff_text_size::{Ranged, TextRange};
 use smallvec::SmallVec;
 use std::ops::Deref;
@@ -67,16 +67,12 @@ impl InlineFileAssertions {
         }
     }
 
-    fn locator(&self) -> Locator {
-        Locator::with_index(&self.source, self.lines.clone())
-    }
-
     fn line_number(&self, range: &impl Ranged) -> OneIndexed {
         self.lines.line_index(range.start())
     }
 
     fn is_own_line_comment(&self, ranged_assertion: &AssertionWithRange) -> bool {
-        CommentRanges::is_own_line(ranged_assertion.start(), &self.locator())
+        CommentRanges::is_own_line(ranged_assertion.start(), self.source.as_str())
     }
 }
 
@@ -131,10 +127,9 @@ impl<'a> Iterator for AssertionWithRangeIterator<'a> {
     type Item = AssertionWithRange<'a>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let locator = self.file_assertions.locator();
         loop {
             let inner_next = self.inner.next()?;
-            let comment = locator.slice(inner_next);
+            let comment = &self.file_assertions.source[inner_next];
             if let Some(assertion) = Assertion::from_comment(comment) {
                 return Some(AssertionWithRange(assertion, inner_next));
             };

crates/ruff_linter/src/checkers/ast/analyze/bindings.rs

@@ -26,11 +26,11 @@ pub(crate) fn bindings(checker: &mut Checker) {
                 && !checker
                     .settings
                     .dummy_variable_rgx
-                    .is_match(binding.name(checker.locator))
+                    .is_match(binding.name(checker.source()))
             {
                 let mut diagnostic = Diagnostic::new(
                     pyflakes::rules::UnusedVariable {
-                        name: binding.name(checker.locator).to_string(),
+                        name: binding.name(checker.source()).to_string(),
                     },
                     binding.range(),
                 );

crates/ruff_linter/src/checkers/ast/analyze/definitions.rs

@@ -1,10 +1,10 @@
 use ruff_python_ast::str::raw_contents_range;
-use ruff_text_size::{Ranged, TextRange};
-
 use ruff_python_semantic::all::DunderAllName;
 use ruff_python_semantic::{
     BindingKind, ContextualizedDefinition, Definition, Export, Member, MemberKind,
 };
+use ruff_source_file::LineRanges;
+use ruff_text_size::{Ranged, TextRange};
 
 use crate::checkers::ast::Checker;
 use crate::codes::Rule;

crates/ruff_linter/src/checkers/ast/analyze/unresolved_references.rs

@@ -17,7 +17,7 @@ pub(crate) fn unresolved_references(checker: &mut Checker) {
             if checker.enabled(Rule::UndefinedLocalWithImportStarUsage) {
                 checker.diagnostics.push(Diagnostic::new(
                     pyflakes::rules::UndefinedLocalWithImportStarUsage {
-                        name: reference.name(checker.locator).to_string(),
+                        name: reference.name(checker.source()).to_string(),
                     },
                     reference.range(),
                 ));
@@ -31,12 +31,12 @@ pub(crate) fn unresolved_references(checker: &mut Checker) {
 
                 // Allow __path__.
                 if checker.path.ends_with("__init__.py") {
-                    if reference.name(checker.locator) == "__path__" {
+                    if reference.name(checker.source()) == "__path__" {
                         continue;
                     }
                 }
 
-                let symbol_name = reference.name(checker.locator);
+                let symbol_name = reference.name(checker.source());
 
                 checker.diagnostics.push(Diagnostic::new(
                     pyflakes::rules::UndefinedName {

crates/ruff_linter/src/checkers/ast/mod.rs

@@ -59,7 +59,7 @@ use ruff_python_semantic::{
 };
 use ruff_python_stdlib::builtins::{python_builtins, MAGIC_GLOBALS};
 use ruff_python_trivia::CommentRanges;
-use ruff_source_file::{Locator, OneIndexed, SourceRow};
+use ruff_source_file::{OneIndexed, SourceRow};
 use ruff_text_size::{Ranged, TextRange, TextSize};
 
 use crate::checkers::ast::annotation::AnnotationContext;
@@ -69,7 +69,7 @@ use crate::noqa::NoqaMapping;
 use crate::registry::Rule;
 use crate::rules::{flake8_pyi, flake8_type_checking, pyflakes, pyupgrade};
 use crate::settings::{flags, LinterSettings};
-use crate::{docstrings, noqa};
+use crate::{docstrings, noqa, Locator};
 
 mod analyze;
 mod annotation;
@@ -352,6 +352,10 @@ impl<'a> Checker<'a> {
         self.locator
     }
 
+    pub(crate) const fn source(&self) -> &'a str {
+        self.locator.contents()
+    }
+
     /// The [`Stylist`] for the current file, which detects the current line ending, quote, and
     /// indentation style.
     pub(crate) const fn stylist(&self) -> &'a Stylist<'a> {

crates/ruff_linter/src/checkers/filesystem.rs

@@ -2,13 +2,13 @@ use std::path::Path;
 
 use ruff_diagnostics::Diagnostic;
 use ruff_python_trivia::CommentRanges;
-use ruff_source_file::Locator;
 
 use crate::registry::Rule;
 use crate::rules::flake8_builtins::rules::builtin_module_shadowing;
 use crate::rules::flake8_no_pep420::rules::implicit_namespace_package;
 use crate::rules::pep8_naming::rules::invalid_module_name;
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 pub(crate) fn check_file_path(
     path: &Path,

crates/ruff_linter/src/checkers/imports.rs

@@ -8,13 +8,13 @@ use ruff_python_ast::{ModModule, PySourceType};
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_parser::Parsed;
-use ruff_source_file::Locator;
 
 use crate::directives::IsortDirectives;
 use crate::registry::Rule;
 use crate::rules::isort;
 use crate::rules::isort::block::{Block, BlockBuilder};
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_imports(

crates/ruff_linter/src/checkers/logical_lines.rs

@@ -1,11 +1,11 @@
-use crate::line_width::IndentWidth;
 use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
 use ruff_python_parser::{TokenKind, Tokens};
-use ruff_source_file::Locator;
+use ruff_source_file::LineRanges;
 use ruff_text_size::{Ranged, TextRange};
 
+use crate::line_width::IndentWidth;
 use crate::registry::{AsRule, Rule};
 use crate::rules::pycodestyle::rules::logical_lines::{
     extraneous_whitespace, indentation, missing_whitespace, missing_whitespace_after_keyword,
@@ -14,6 +14,7 @@ use crate::rules::pycodestyle::rules::logical_lines::{
     whitespace_before_comment, whitespace_before_parameters, LogicalLines, TokenFlags,
 };
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 /// Return the amount of indentation, expanding tabs to the next multiple of the settings' tab size.
 pub(crate) fn expand_indent(line: &str, indent_width: IndentWidth) -> usize {

crates/ruff_linter/src/checkers/noqa.rs

@@ -7,7 +7,6 @@ use rustc_hash::FxHashSet;
 
 use ruff_diagnostics::{Diagnostic, Edit, Fix};
 use ruff_python_trivia::CommentRanges;
-use ruff_source_file::Locator;
 use ruff_text_size::Ranged;
 
 use crate::fix::edits::delete_comment;
@@ -20,6 +19,7 @@ use crate::rules::pygrep_hooks;
 use crate::rules::ruff;
 use crate::rules::ruff::rules::{UnusedCodes, UnusedNOQA};
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_noqa(
@@ -33,13 +33,8 @@ pub(crate) fn check_noqa(
     settings: &LinterSettings,
 ) -> Vec<usize> {
     // Identify any codes that are globally exempted (within the current file).
-    let file_noqa_directives = FileNoqaDirectives::extract(
-        locator.contents(),
-        comment_ranges,
-        &settings.external,
-        path,
-        locator,
-    );
+    let file_noqa_directives =
+        FileNoqaDirectives::extract(locator, comment_ranges, &settings.external, path);
     let exemption = FileExemption::from(&file_noqa_directives);
 
     // Extract all `noqa` directives.

crates/ruff_linter/src/checkers/physical_lines.rs

@@ -3,7 +3,7 @@
 use ruff_diagnostics::Diagnostic;
 use ruff_python_codegen::Stylist;
 use ruff_python_index::Indexer;
-use ruff_source_file::{Locator, UniversalNewlines};
+use ruff_source_file::UniversalNewlines;
 use ruff_text_size::TextSize;
 
 use crate::registry::Rule;
@@ -14,6 +14,7 @@ use crate::rules::pycodestyle::rules::{
 };
 use crate::rules::pylint;
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 pub(crate) fn check_physical_lines(
     locator: &Locator,
@@ -92,12 +93,12 @@ mod tests {
     use ruff_python_codegen::Stylist;
     use ruff_python_index::Indexer;
     use ruff_python_parser::parse_module;
-    use ruff_source_file::Locator;
 
     use crate::line_width::LineLength;
     use crate::registry::Rule;
     use crate::rules::pycodestyle;
     use crate::settings::LinterSettings;
+    use crate::Locator;
 
     use super::check_physical_lines;
 
@@ -106,8 +107,8 @@ mod tests {
         let line = "'\u{4e9c}' * 2"; // 7 in UTF-32, 9 in UTF-8.
         let locator = Locator::new(line);
         let parsed = parse_module(line).unwrap();
-        let indexer = Indexer::from_tokens(parsed.tokens(), &locator);
-        let stylist = Stylist::from_tokens(parsed.tokens(), &locator);
+        let indexer = Indexer::from_tokens(parsed.tokens(), locator.contents());
+        let stylist = Stylist::from_tokens(parsed.tokens(), locator.contents());
 
         let check_with_max_line_length = |line_length: LineLength| {
             check_physical_lines(

crates/ruff_linter/src/checkers/tokens.rs

@@ -2,14 +2,12 @@
 
 use std::path::Path;
 
+use ruff_diagnostics::Diagnostic;
 use ruff_notebook::CellOffsets;
 use ruff_python_ast::PySourceType;
 use ruff_python_codegen::Stylist;
-
-use ruff_diagnostics::Diagnostic;
 use ruff_python_index::Indexer;
 use ruff_python_parser::Tokens;
-use ruff_source_file::Locator;
 use ruff_text_size::Ranged;
 
 use crate::directives::TodoComment;
@@ -20,6 +18,7 @@ use crate::rules::{
     flake8_pyi, flake8_todos, pycodestyle, pygrep_hooks, pylint, pyupgrade, ruff,
 };
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn check_tokens(

crates/ruff_linter/src/directives.rs

@@ -4,15 +4,16 @@ use std::iter::Peekable;
 use std::str::FromStr;
 
 use bitflags::bitflags;
+
+use ruff_python_index::Indexer;
 use ruff_python_parser::{TokenKind, Tokens};
 use ruff_python_trivia::CommentRanges;
+use ruff_source_file::LineRanges;
 use ruff_text_size::{Ranged, TextLen, TextRange, TextSize};
 
-use ruff_python_index::Indexer;
-use ruff_source_file::Locator;
-
 use crate::noqa::NoqaMapping;
 use crate::settings::LinterSettings;
+use crate::Locator;
 
 bitflags! {
     #[derive(Debug, Copy, Clone)]
@@ -360,24 +361,23 @@ impl TodoDirectiveKind {
 
 #[cfg(test)]
 mod tests {
+    use ruff_python_index::Indexer;
     use ruff_python_parser::parse_module;
     use ruff_python_trivia::CommentRanges;
     use ruff_text_size::{TextLen, TextRange, TextSize};
 
-    use ruff_python_index::Indexer;
-    use ruff_source_file::Locator;
-
     use crate::directives::{
         extract_isort_directives, extract_noqa_line_for, TodoDirective, TodoDirectiveKind,
     };
     use crate::noqa::NoqaMapping;
+    use crate::Locator;
 
     use super::IsortDirectives;
 
     fn noqa_mappings(contents: &str) -> NoqaMapping {
         let parsed = parse_module(contents).unwrap();
         let locator = Locator::new(contents);
-        let indexer = Indexer::from_tokens(parsed.tokens(), &locator);
+        let indexer = Indexer::from_tokens(parsed.tokens(), locator.contents());
 
         extract_noqa_line_for(parsed.tokens(), &locator, &indexer)
     }

crates/ruff_linter/src/doc_lines.rs

@@ -4,12 +4,13 @@
 use std::iter::FusedIterator;
 use std::slice::Iter;
 
+use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
 use ruff_python_ast::{self as ast, Stmt, Suite};
 use ruff_python_parser::{Token, TokenKind, Tokens};
+use ruff_source_file::UniversalNewlineIterator;
 use ruff_text_size::{Ranged, TextSize};
 
-use ruff_python_ast::statement_visitor::{walk_stmt, StatementVisitor};
-use ruff_source_file::{Locator, UniversalNewlineIterator};
+use crate::Locator;
 
 /// Extract doc lines (standalone comments) from a token sequence.
 pub(crate) fn doc_lines_from_tokens(tokens: &Tokens) -> DocLines {

crates/ruff_linter/src/fix/codemods.rs

@@ -13,9 +13,9 @@ use unicode_normalization::UnicodeNormalization;
 use ruff_python_ast::name::UnqualifiedName;
 use ruff_python_ast::Stmt;
 use ruff_python_codegen::Stylist;
-use ruff_source_file::Locator;
 
 use crate::cst::matchers::match_statement;
+use crate::Locator;
 
 /// Glue code to make libcst codegen work with ruff's Stylist
 pub(crate) trait CodegenStylist<'a>: Codegen<'a> {