mirrors/ruff
1
0
Fork 0
mirror of https://github.com/astral-sh/ruff.git synced 2025-07-22 20:45:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Rename some methods on Locator (#2926)

Browse source
This commit is contained in:
Charlie Marsh 2023-02-15 10:21:49 -05:00 • committed by GitHub
parent 976fe364d4
commit 57a5071b4e
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
50 changed files with 138 additions and 245 deletions
Download patch file Download diff file Expand all files Collapse all files

32
crates/ruff/src/ast/helpers.rs
View file

@ -596,7 +596,7 @@ pub fn has_comments<T>(located: &Located<T>, locator: &Locator) -> bool {
/// Returns `true` if a [`Range`] includes at least one comment.
pub fn has_comments_in(range: Range, locator: &Locator) -> bool {
for tok in lexer::make_tokenizer(locator.slice_source_code_range(&range)) {
for tok in lexer::make_tokenizer(locator.slice(&range)) {
match tok {
Ok((_, tok, _)) => {
if matches!(tok, Tok::Comment(..)) {
@ -756,7 +756,7 @@ pub fn to_relative(absolute: Location, base: Location) -> Location {
/// Return `true` if a [`Located`] has leading content.
pub fn match_leading_content<T>(located: &Located<T>, locator: &Locator) -> bool {
let range = Range::new(Location::new(located.location.row(), 0), located.location);
let prefix = locator.slice_source_code_range(&range);
let prefix = locator.slice(&range);
prefix.chars().any(|char| !char.is_whitespace())
}
@ -766,7 +766,7 @@ pub fn match_trailing_content<T>(located: &Located<T>, locator: &Locator) -> boo
located.end_location.unwrap(),
Location::new(located.end_location.unwrap().row() + 1, 0),
);
let suffix = locator.slice_source_code_range(&range);
let suffix = locator.slice(&range);
for char in suffix.chars() {
if char == '#' {
return false;
@ -784,7 +784,7 @@ pub fn match_trailing_comment<T>(located: &Located<T>, locator: &Locator) -> Opt
located.end_location.unwrap(),
Location::new(located.end_location.unwrap().row() + 1, 0),
);
let suffix = locator.slice_source_code_range(&range);
let suffix = locator.slice(&range);
for (i, char) in suffix.chars().enumerate() {
if char == '#' {
return Some(i);
@ -798,8 +798,7 @@ pub fn match_trailing_comment<T>(located: &Located<T>, locator: &Locator) -> Opt
/// Return the number of trailing empty lines following a statement.
pub fn count_trailing_lines(stmt: &Stmt, locator: &Locator) -> usize {
let suffix =
locator.slice_source_code_at(Location::new(stmt.end_location.unwrap().row() + 1, 0));
let suffix = locator.skip(Location::new(stmt.end_location.unwrap().row() + 1, 0));
suffix
.lines()
.take_while(|line| line.trim().is_empty())
@ -808,7 +807,7 @@ pub fn count_trailing_lines(stmt: &Stmt, locator: &Locator) -> usize {
/// Return the range of the first parenthesis pair after a given [`Location`].
pub fn match_parens(start: Location, locator: &Locator) -> Option<Range> {
let contents = locator.slice_source_code_at(start);
let contents = locator.skip(start);
let mut fix_start = None;
let mut fix_end = None;
let mut count: usize = 0;
@ -843,7 +842,7 @@ pub fn identifier_range(stmt: &Stmt, locator: &Locator) -> Range {
| StmtKind::FunctionDef { .. }
| StmtKind::AsyncFunctionDef { .. }
) {
let contents = locator.slice_source_code_range(&Range::from_located(stmt));
let contents = locator.slice(&Range::from_located(stmt));
for (start, tok, end) in lexer::make_tokenizer_located(contents, stmt.location).flatten() {
if matches!(tok, Tok::Name { .. }) {
return Range::new(start, end);
@ -871,7 +870,7 @@ pub fn binding_range(binding: &Binding, locator: &Locator) -> Range {
// Return the ranges of `Name` tokens within a specified node.
pub fn find_names<T>(located: &Located<T>, locator: &Locator) -> Vec<Range> {
let contents = locator.slice_source_code_range(&Range::from_located(located));
let contents = locator.slice(&Range::from_located(located));
lexer::make_tokenizer_located(contents, located.location)
.flatten()
.filter(|(_, tok, _)| matches!(tok, Tok::Name { .. }))
@ -890,8 +889,7 @@ pub fn excepthandler_name_range(handler: &Excepthandler, locator: &Locator) -> O
match (name, type_) {
(Some(_), Some(type_)) => {
let type_end_location = type_.end_location.unwrap();
let contents =
locator.slice_source_code_range(&Range::new(type_end_location, body[0].location));
let contents = locator.slice(&Range::new(type_end_location, body[0].location));
let range = lexer::make_tokenizer_located(contents, type_end_location)
.flatten()
.tuple_windows()
@ -915,7 +913,7 @@ pub fn except_range(handler: &Excepthandler, locator: &Locator) -> Range {
.expect("Expected body to be non-empty")
.location
};
let contents = locator.slice_source_code_range(&Range {
let contents = locator.slice(&Range {
location: handler.location,
end_location: end,
});
@ -932,7 +930,7 @@ pub fn except_range(handler: &Excepthandler, locator: &Locator) -> Range {
/// Find f-strings that don't contain any formatted values in a `JoinedStr`.
pub fn find_useless_f_strings(expr: &Expr, locator: &Locator) -> Vec<(Range, Range)> {
let contents = locator.slice_source_code_range(&Range::from_located(expr));
let contents = locator.slice(&Range::from_located(expr));
lexer::make_tokenizer_located(contents, expr.location)
.flatten()
.filter_map(|(location, tok, end_location)| match tok {
@ -940,7 +938,7 @@ pub fn find_useless_f_strings(expr: &Expr, locator: &Locator) -> Vec<(Range, Ran
kind: StringKind::FString | StringKind::RawFString,
..
} => {
let first_char = locator.slice_source_code_range(&Range {
let first_char = locator.slice(&Range {
location,
end_location: Location::new(location.row(), location.column() + 1),
});
@ -980,7 +978,7 @@ pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
.expect("Expected body to be non-empty")
.end_location
.unwrap();
let contents = locator.slice_source_code_range(&Range {
let contents = locator.slice(&Range {
location: body_end,
end_location: orelse
.first()
@ -1002,7 +1000,7 @@ pub fn else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
/// Return the `Range` of the first `Tok::Colon` token in a `Range`.
pub fn first_colon_range(range: Range, locator: &Locator) -> Option<Range> {
let contents = locator.slice_source_code_range(&range);
let contents = locator.slice(&range);
let range = lexer::make_tokenizer_located(contents, range.location)
.flatten()
.find(|(_, kind, _)| matches!(kind, Tok::Colon))
@ -1032,7 +1030,7 @@ pub fn elif_else_range(stmt: &Stmt, locator: &Locator) -> Option<Range> {
[stmt, ..] => stmt.location,
_ => return None,
};
let contents = locator.slice_source_code_range(&Range::new(start, end));
let contents = locator.slice(&Range::new(start, end));
let range = lexer::make_tokenizer_located(contents, start)
.flatten()
.find(|(_, kind, _)| matches!(kind, Tok::Elif | Tok::Else))

2
crates/ruff/src/ast/whitespace.rs
View file

@ -8,7 +8,7 @@ use crate::source_code::Locator;
/// Extract the leading indentation from a line.
pub fn indentation<'a, T>(locator: &'a Locator, located: &'a Located<T>) -> Option<&'a str> {
let range = Range::from_located(located);
let indentation = locator.slice_source_code_range(&Range::new(
let indentation = locator.slice(&Range::new(
Location::new(range.location.row(), 0),
Location::new(range.location.row(), range.location.column()),
));

10
crates/ruff/src/autofix/helpers.rs
View file

@ -81,7 +81,7 @@ fn is_lone_child(child: &Stmt, parent: &Stmt, deleted: &[&Stmt]) -> Result<bool>
/// Return the location of a trailing semicolon following a `Stmt`, if it's part
/// of a multi-statement line.
fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
let contents = locator.slice_source_code_at(stmt.end_location.unwrap());
let contents = locator.skip(stmt.end_location.unwrap());
for (row, line) in LinesWithTrailingNewline::from(contents).enumerate() {
let trimmed = line.trim();
if trimmed.starts_with(';') {
@ -104,7 +104,7 @@ fn trailing_semicolon(stmt: &Stmt, locator: &Locator) -> Option<Location> {
/// Find the next valid break for a `Stmt` after a semicolon.
fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
let start_location = Location::new(semicolon.row(), semicolon.column() + 1);
let contents = locator.slice_source_code_at(start_location);
let contents = locator.skip(start_location);
for (row, line) in LinesWithTrailingNewline::from(contents).enumerate() {
let trimmed = line.trim();
// Skip past any continuations.
@ -136,7 +136,7 @@ fn next_stmt_break(semicolon: Location, locator: &Locator) -> Location {
/// Return `true` if a `Stmt` occurs at the end of a file.
fn is_end_of_file(stmt: &Stmt, locator: &Locator) -> bool {
let contents = locator.slice_source_code_at(stmt.end_location.unwrap());
let contents = locator.skip(stmt.end_location.unwrap());
contents.is_empty()
}
@ -209,7 +209,7 @@ pub fn remove_unused_imports<'a>(
indexer: &Indexer,
stylist: &Stylist,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
let module_text = locator.slice(&Range::from_located(stmt));
let mut tree = match_module(module_text)?;
let Some(Statement::Simple(body)) = tree.body.first_mut() else {
@ -339,7 +339,7 @@ pub fn remove_argument(
remove_parentheses: bool,
) -> Result<Fix> {
// TODO(sbrugman): Preserve trailing comments.
let contents = locator.slice_source_code_at(stmt_at);
let contents = locator.skip(stmt_at);
let mut fix_start = None;
let mut fix_end = None;

8
crates/ruff/src/autofix/mod.rs
View file

@ -54,7 +54,7 @@ fn apply_fixes<'a>(
}
// Add all contents from `last_pos` to `fix.location`.
let slice = locator.slice_source_code_range(&Range::new(last_pos, fix.location));
let slice = locator.slice(&Range::new(last_pos, fix.location));
output.push_str(slice);
// Add the patch itself.
@ -67,7 +67,7 @@ fn apply_fixes<'a>(
}
// Add the remaining content.
let slice = locator.slice_source_code_at(last_pos);
let slice = locator.skip(last_pos);
output.push_str(slice);
(output, fixed)
@ -78,14 +78,14 @@ pub(crate) fn apply_fix(fix: &Fix, locator: &Locator) -> String {
let mut output = String::with_capacity(locator.len());
// Add all contents from `last_pos` to `fix.location`.
let slice = locator.slice_source_code_range(&Range::new(Location::new(1, 0), fix.location));
let slice = locator.slice(&Range::new(Location::new(1, 0), fix.location));
output.push_str(slice);
// Add the patch itself.
output.push_str(&fix.content);
// Add the remaining content.
let slice = locator.slice_source_code_at(fix.end_location);
let slice = locator.skip(fix.end_location);
output.push_str(slice);
output

6
crates/ruff/src/checkers/ast.rs
View file

@ -5221,10 +5221,8 @@ impl<'a> Checker<'a> {
// Extract a `Docstring` from a `Definition`.
let expr = definition.docstring.unwrap();
let contents = self
.locator
.slice_source_code_range(&Range::from_located(expr));
let indentation = self.locator.slice_source_code_range(&Range::new(
let contents = self.locator.slice(&Range::from_located(expr));
let indentation = self.locator.slice(&Range::new(
Location::new(expr.location.row(), 0),
Location::new(expr.location.row(), expr.location.column()),
));

3
crates/ruff/src/checkers/logical_lines.rs
View file

@ -52,8 +52,7 @@ pub fn check_logical_lines(
// Extract the indentation level.
let start_loc = line.mapping[0].1;
let start_line = locator
.slice_source_code_range(&Range::new(Location::new(start_loc.row(), 0), start_loc));
let start_line = locator.slice(&Range::new(Location::new(start_loc.row(), 0), start_loc));
let indent_level = expand_indent(start_line);
let indent_size = 4;

4
crates/ruff/src/message.rs
View file

@ -71,9 +71,9 @@ impl Source {
} else {
Location::new(diagnostic.end_location.row() + 1, 0)
};
let source = locator.slice_source_code_range(&Range::new(location, end_location));
let source = locator.slice(&Range::new(location, end_location));
let num_chars_in_range = locator
.slice_source_code_range(&Range::new(diagnostic.location, diagnostic.end_location))
.slice(&Range::new(diagnostic.location, diagnostic.end_location))
.chars()
.count();
Source {

2
crates/ruff/src/noqa.rs
View file

@ -87,7 +87,7 @@ pub fn rule_is_ignored(
locator: &Locator,
) -> bool {
let noqa_lineno = noqa_line_for.get(&lineno).unwrap_or(&lineno);
let line = locator.slice_source_code_range(&Range::new(
let line = locator.slice(&Range::new(
Location::new(*noqa_lineno, 0),
Location::new(noqa_lineno + 1, 0),
));

2
crates/ruff/src/rules/eradicate/rules.rs
View file

@ -55,7 +55,7 @@ pub fn commented_out_code(
) -> Option<Diagnostic> {
let location = Location::new(start.row(), 0);
let end_location = Location::new(end.row() + 1, 0);
let line = locator.slice_source_code_range(&Range::new(location, end_location));
let line = locator.slice(&Range::new(location, end_location));
// Verify that the comment is on its own line, and that it contains code.
if is_standalone_comment(line) && comment_contains_code(line, &settings.task_tags[..]) {

2
crates/ruff/src/rules/flake8_annotations/fixes.rs
View file

@ -10,7 +10,7 @@ use crate::source_code::Locator;
/// ANN204
pub fn add_return_none_annotation(locator: &Locator, stmt: &Stmt) -> Result<Fix> {
let range = Range::from_located(stmt);
let contents = locator.slice_source_code_range(&range);
let contents = locator.slice(&range);
// Find the colon (following the `def` keyword).
let mut seen_lpar = false;

30
crates/ruff/src/rules/flake8_comprehensions/fixes.rs
View file

@ -35,7 +35,7 @@ pub fn fix_unnecessary_generator_list(
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
// Expr(Call(GeneratorExp)))) -> Expr(ListComp)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -82,7 +82,7 @@ pub fn fix_unnecessary_generator_set(
parent: Option<&rustpython_parser::ast::Expr>,
) -> Result<Fix> {
// Expr(Call(GeneratorExp)))) -> Expr(SetComp)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -139,7 +139,7 @@ pub fn fix_unnecessary_generator_dict(
expr: &rustpython_parser::ast::Expr,
parent: Option<&rustpython_parser::ast::Expr>,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -213,7 +213,7 @@ pub fn fix_unnecessary_list_comprehension_set(
) -> Result<Fix> {
// Expr(Call(ListComp)))) ->
// Expr(SetComp)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -257,7 +257,7 @@ pub fn fix_unnecessary_list_comprehension_dict(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -356,7 +356,7 @@ pub fn fix_unnecessary_literal_set(
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
// Expr(Call(List|Tuple)))) -> Expr(Set)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let mut call = match_call(body)?;
@ -407,7 +407,7 @@ pub fn fix_unnecessary_literal_dict(
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
// Expr(Call(List|Tuple)))) -> Expr(Dict)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -480,7 +480,7 @@ pub fn fix_unnecessary_collection_call(
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
// Expr(Call("list" | "tuple" | "dict")))) -> Expr(List|Tuple|Dict)
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -593,7 +593,7 @@ pub fn fix_unnecessary_literal_within_tuple_call(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -652,7 +652,7 @@ pub fn fix_unnecessary_literal_within_list_call(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -714,7 +714,7 @@ pub fn fix_unnecessary_list_call(
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
// Expr(Call(List|Tuple)))) -> Expr(List|Tuple)))
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;
@ -744,7 +744,7 @@ pub fn fix_unnecessary_call_around_sorted(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let outer_call = match_call(body)?;
@ -871,7 +871,7 @@ pub fn fix_unnecessary_double_cast_or_process(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let body = match_expr(&mut tree)?;
let mut outer_call = match_call(body)?;
@ -910,7 +910,7 @@ pub fn fix_unnecessary_comprehension(
stylist: &Stylist,
expr: &rustpython_parser::ast::Expr,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
@ -986,7 +986,7 @@ pub fn fix_unnecessary_map(
parent: Option<&rustpython_parser::ast::Expr>,
kind: &str,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
let call = match_call(body)?;

4
crates/ruff/src/rules/flake8_quotes/rules.rs
View file

@ -263,7 +263,7 @@ fn docstring(
) -> Option<Diagnostic> {
let quotes_settings = &settings.flake8_quotes;
let text = locator.slice_source_code_range(&Range::new(start, end));
let text = locator.slice(&Range::new(start, end));
let trivia: Trivia = text.into();
if trivia
@ -310,7 +310,7 @@ fn strings(
let trivia = sequence
.iter()
.map(|(start, end)| {
let text = locator.slice_source_code_range(&Range::new(*start, *end));
let text = locator.slice(&Range::new(*start, *end));
let trivia: Trivia = text.into();
trivia
})

2
crates/ruff/src/rules/flake8_simplify/rules/fix_if.rs
View file

@ -39,7 +39,7 @@ pub(crate) fn fix_nested_if_statements(
};
// Extract the module text.
let contents = locator.slice_source_code_range(&Range::new(
let contents = locator.slice(&Range::new(
Location::new(stmt.location.row(), 0),
Location::new(stmt.end_location.unwrap().row() + 1, 0),
));

2
crates/ruff/src/rules/flake8_simplify/rules/fix_with.rs
View file

@ -20,7 +20,7 @@ pub(crate) fn fix_multiple_with_statements(
};
// Extract the module text.
let contents = locator.slice_source_code_range(&Range::new(
let contents = locator.slice(&Range::new(
Location::new(stmt.location.row(), 0),
Location::new(stmt.end_location.unwrap().row() + 1, 0),
));

8
crates/ruff/src/rules/flake8_simplify/rules/key_in_dict.rs
View file

@ -47,12 +47,8 @@ fn key_in_dict(checker: &mut Checker, left: &Expr, right: &Expr, range: Range) {
}
// Slice exact content to preserve formatting.
let left_content = checker
.locator
.slice_source_code_range(&Range::from_located(left));
let value_content = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let left_content = checker.locator.slice(&Range::from_located(left));
let value_content = checker.locator.slice(&Range::from_located(value));
let mut diagnostic = Diagnostic::new(
KeyInDict {

2
crates/ruff/src/rules/flake8_simplify/rules/yoda_conditions.rs
View file

@ -57,7 +57,7 @@ fn is_constant_like(expr: &Expr) -> bool {
/// Generate a fix to reverse a comparison.
fn reverse_comparison(expr: &Expr, locator: &Locator, stylist: &Stylist) -> Result<String> {
let range = Range::from_located(expr);
let contents = locator.slice_source_code_range(&range);
let contents = locator.slice(&range);
let mut expression = match_expression(contents)?;
let mut comparison = match_comparison(&mut expression)?;

2
crates/ruff/src/rules/isort/comments.rs
View file

@ -16,7 +16,7 @@ pub struct Comment<'a> {
/// Collect all comments in an import block.
pub fn collect_comments<'a>(range: &Range, locator: &'a Locator) -> Vec<Comment<'a>> {
let contents = locator.slice_source_code_range(range);
let contents = locator.slice(range);
lexer::make_tokenizer_located(contents, range.location)
.flatten()
.filter_map(|(start, tok, end)| {

6
crates/ruff/src/rules/isort/helpers.rs
View file

@ -10,7 +10,7 @@ use crate::source_code::Locator;
/// Return `true` if a `StmtKind::ImportFrom` statement ends with a magic
/// trailing comma.
pub fn trailing_comma(stmt: &Stmt, locator: &Locator) -> TrailingComma {
let contents = locator.slice_source_code_range(&Range::from_located(stmt));
let contents = locator.slice(&Range::from_located(stmt));
let mut count: usize = 0;
let mut trailing_comma = TrailingComma::Absent;
for (_, tok, _) in lexer::make_tokenizer(contents).flatten() {
@ -63,7 +63,7 @@ pub fn has_comment_break(stmt: &Stmt, locator: &Locator) -> bool {
// # Direct comment.
// def f(): pass
let mut seen_blank = false;
for line in locator.slice_source_code_until(stmt.location).lines().rev() {
for line in locator.take(stmt.location).lines().rev() {
let line = line.trim();
if seen_blank {
if line.starts_with('#') {
@ -109,7 +109,7 @@ pub fn find_splice_location(body: &[Stmt], locator: &Locator) -> Location {
let mut splice = match_docstring_end(body).unwrap_or_default();
// Find the first token that isn't a comment or whitespace.
let contents = locator.slice_source_code_at(splice);
let contents = locator.skip(splice);
for (.., tok, end) in lexer::make_tokenizer(contents).flatten() {
if matches!(tok, Tok::Comment(..) | Tok::Newline) {
splice = end;

4
crates/ruff/src/rules/isort/rules/organize_imports.rs
View file

@ -83,7 +83,7 @@ pub fn organize_imports(
autofix: flags::Autofix,
package: Option<&Path>,
) -> Option<Diagnostic> {
let indentation = locator.slice_source_code_range(&extract_indentation_range(&block.imports));
let indentation = locator.slice(&extract_indentation_range(&block.imports));
let indentation = leading_space(indentation);
let range = extract_range(&block.imports);
@ -147,7 +147,7 @@ pub fn organize_imports(
Location::new(range.location.row(), 0),
Location::new(range.end_location.row() + 1 + num_trailing_lines, 0),
);
let actual = locator.slice_source_code_range(&range);
let actual = locator.slice(&range);
if matches_ignoring_indentation(actual, &expected) {
None
} else {

3
crates/ruff/src/rules/pandas_vet/fixes.rs
View file

@ -50,8 +50,7 @@ pub fn fix_inplace_argument(
// Apply the deletion step.
// TODO(charlie): Find a way to
let contents =
locator.slice_source_code_range(&Range::new(expr.location, expr.end_location.unwrap()));
let contents = locator.slice(&Range::new(expr.location, expr.end_location.unwrap()));
let output = apply_fix(&fix_me, &Locator::new(contents));
// Obtain the name prefix.

6
crates/ruff/src/rules/pycodestyle/logical_lines.rs
View file

@ -150,7 +150,7 @@ fn build_line<'a>(
let text = if let Tok::String { .. } = tok {
"\"xxx\""
} else {
locator.slice_source_code_range(&Range {
locator.slice(&Range {
location: *start,
end_location: *end,
})
@ -158,7 +158,7 @@ fn build_line<'a>(
if let Some(prev) = prev {
if prev.row() != start.row() {
let prev_text = locator.slice_source_code_range(&Range {
let prev_text = locator.slice(&Range {
location: Location::new(prev.row(), prev.column() - 1),
end_location: Location::new(prev.row(), prev.column()),
});
@ -170,7 +170,7 @@ fn build_line<'a>(
length += 1;
}
} else if prev.column() != start.column() {
let prev_text = locator.slice_source_code_range(&Range {
let prev_text = locator.slice(&Range {
location: *prev,
end_location: *start,
});

2
crates/ruff/src/rules/pycodestyle/rules/invalid_escape_sequence.rs
View file

@ -49,7 +49,7 @@ pub fn invalid_escape_sequence(
) -> Vec<Diagnostic> {
let mut diagnostics = vec![];
let text = locator.slice_source_code_range(&Range::new(start, end));
let text = locator.slice(&Range::new(start, end));
// Determine whether the string is single- or triple-quoted.
let quote = extract_quote(text);

2
crates/ruff/src/rules/pycodestyle/rules/lambda_assignment.rs
View file

@ -35,7 +35,7 @@ pub fn lambda_assignment(checker: &mut Checker, target: &Expr, value: &Expr, stm
if !match_leading_content(stmt, checker.locator)
&& !match_trailing_content(stmt, checker.locator)
{
let first_line = checker.locator.slice_source_code_range(&Range::new(
let first_line = checker.locator.slice(&Range::new(
Location::new(stmt.location.row(), 0),
Location::new(stmt.location.row() + 1, 0),
));

2
crates/ruff/src/rules/pycodestyle/rules/whitespace_before_comment.rs
View file

@ -60,7 +60,7 @@ pub fn whitespace_before_comment(
let mut prev_end = Location::new(0, 0);
for (start, tok, end) in tokens {
if let Tok::Comment(text) = tok {
let line = locator.slice_source_code_range(&Range::new(
let line = locator.slice(&Range::new(
Location::new(start.row(), 0),
Location::new(start.row(), start.column()),
));

15
crates/ruff/src/rules/pydocstyle/rules/blank_before_after_class.rs
View file

@ -71,10 +71,9 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
.rules
.enabled(&Rule::NoBlankLineBeforeClass)
{
let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent),
&Range::from_located(docstring.expr),
);
let before = checker
.locator
.slice(&Range::new(parent.location, docstring.expr.location));
let blank_lines_before = before
.lines()
@ -134,10 +133,10 @@ pub fn blank_before_after_class(checker: &mut Checker, docstring: &Docstring) {
.rules
.enabled(&Rule::OneBlankLineAfterClass)
{
let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent),
&Range::from_located(docstring.expr),
);
let after = checker.locator.slice(&Range::new(
docstring.expr.end_location.unwrap(),
parent.end_location.unwrap(),
));
let all_blank_after = after
.lines()

15
crates/ruff/src/rules/pydocstyle/rules/blank_before_after_function.rs
View file

@ -62,10 +62,9 @@ pub fn blank_before_after_function(checker: &mut Checker, docstring: &Docstring)
.rules
.enabled(&Rule::NoBlankLineBeforeFunction)
{
let (before, ..) = checker.locator.partition_source_code_at(
&Range::from_located(parent),
&Range::from_located(docstring.expr),
);
let before = checker
.locator
.slice(&Range::new(parent.location, docstring.expr.location));
let blank_lines_before = before
.lines()
@ -96,10 +95,10 @@ pub fn blank_before_after_function(checker: &mut Checker, docstring: &Docstring)
.rules
.enabled(&Rule::NoBlankLineAfterFunction)
{
let (_, _, after) = checker.locator.partition_source_code_at(
&Range::from_located(parent),
&Range::from_located(docstring.expr),
);
let after = checker.locator.slice(&Range::new(
docstring.expr.end_location.unwrap(),
parent.end_location.unwrap(),
));
// If the docstring is only followed by blank and commented lines, abort.
let all_blank_after = after

9
crates/ruff/src/rules/pydocstyle/rules/multi_line_summary_start.rs
View file

@ -105,11 +105,10 @@ pub fn multi_line_summary_start(checker: &mut Checker, docstring: &Docstring) {
| DefinitionKind::NestedFunction(parent)
| DefinitionKind::Method(parent) = &docstring.kind
{
let parent_indentation =
checker.locator.slice_source_code_range(&Range::new(
Location::new(parent.location.row(), 0),
Location::new(parent.location.row(), parent.location.column()),
));
let parent_indentation = checker.locator.slice(&Range::new(
Location::new(parent.location.row(), 0),
Location::new(parent.location.row(), parent.location.column()),
));
if parent_indentation.chars().all(char::is_whitespace) {
indentation.clear();
indentation.push_str(parent_indentation);

6
crates/ruff/src/rules/pyflakes/fixes.rs
View file

@ -17,7 +17,7 @@ pub fn remove_unused_format_arguments_from_dict(
locator: &Locator,
stylist: &Stylist,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
let module_text = locator.slice(&Range::from_located(stmt));
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
@ -68,7 +68,7 @@ pub fn remove_unused_keyword_arguments_from_format_call(
locator: &Locator,
stylist: &Stylist,
) -> Result<Fix> {
let module_text = locator.slice_source_code_range(&location);
let module_text = locator.slice(&location);
let mut tree = match_module(module_text)?;
let mut body = match_expr(&mut tree)?;
@ -115,7 +115,7 @@ pub fn remove_exception_handler_assignment(
excepthandler: &Excepthandler,
locator: &Locator,
) -> Result<Fix> {
let contents = locator.slice_source_code_range(&Range::from_located(excepthandler));
let contents = locator.slice(&Range::from_located(excepthandler));
let mut fix_start = None;
let mut fix_end = None;

2
crates/ruff/src/rules/pyflakes/rules/invalid_literal_comparisons.rs
View file

@ -61,7 +61,7 @@ pub fn invalid_literal_comparison(
comparators: &[Expr],
location: Range,
) {
let located = Lazy::new(|| locate_cmpops(checker.locator.slice_source_code_range(&location)));
let located = Lazy::new(|| locate_cmpops(checker.locator.slice(&location)));
let mut left = left;
for (index, (op, right)) in izip!(ops, comparators).enumerate() {
if matches!(op, Cmpop::Is | Cmpop::IsNot)

4
crates/ruff/src/rules/pyflakes/rules/unused_variable.rs
View file

@ -67,7 +67,7 @@ fn match_token_after<F, T>(located: &Located<T>, locator: &Locator, f: F) -> Ran
where
F: Fn(Tok) -> bool,
{
let contents = locator.slice_source_code_at(located.location);
let contents = locator.skip(located.location);
// Track the bracket depth.
let mut par_count = 0;
@ -129,7 +129,7 @@ fn match_token<F, T>(located: &Located<T>, locator: &Locator, f: F) -> Range
where
F: Fn(Tok) -> bool,
{
let contents = locator.slice_source_code_at(located.location);
let contents = locator.skip(located.location);
// Track the bracket depth.
let mut par_count = 0;

8
crates/ruff/src/rules/pylint/rules/bad_string_format_type.rs
View file

@ -245,9 +245,7 @@ fn is_valid_dict(
/// PLE1307
pub fn bad_string_format_type(checker: &mut Checker, expr: &Expr, right: &Expr) {
// Grab each string segment (in case there's an implicit concatenation).
let content = checker
.locator
.slice_source_code_range(&Range::from_located(expr));
let content = checker.locator.slice(&Range::from_located(expr));
let mut strings: Vec<(Location, Location)> = vec![];
for (start, tok, end) in lexer::make_tokenizer_located(content, expr.location).flatten() {
if matches!(tok, Tok::String { .. }) {
@ -266,9 +264,7 @@ pub fn bad_string_format_type(checker: &mut Checker, expr: &Expr, right: &Expr)
// Parse each string segment.
let mut format_strings = vec![];
for (start, end) in &strings {
let string = checker
.locator
.slice_source_code_range(&Range::new(*start, *end));
let string = checker.locator.slice(&Range::new(*start, *end));
let (Some(leader), Some(trailer)) = (leading_quote(string), trailing_quote(string)) else {
return;
};

8
crates/ruff/src/rules/pyupgrade/fixes.rs
View file

@ -20,7 +20,7 @@ pub fn adjust_indentation(
locator: &Locator,
stylist: &Stylist,
) -> Result<String> {
let contents = locator.slice_source_code_range(&range);
let contents = locator.slice(&range);
let module_text = format!("def f():{}{contents}", stylist.line_ending().as_str());
@ -69,7 +69,7 @@ pub fn remove_class_def_base(
/// Generate a fix to remove arguments from a `super` call.
pub fn remove_super_arguments(locator: &Locator, stylist: &Stylist, expr: &Expr) -> Option<Fix> {
let range = Range::from_located(expr);
let contents = locator.slice_source_code_range(&range);
let contents = locator.slice(&range);
let mut tree = libcst_native::parse_module(contents, None).ok()?;
@ -151,7 +151,7 @@ pub fn remove_import_members(contents: &str, members: &[&str]) -> String {
// It's possible that `last_pos` is after `fix.location`, if we're removing the
// first _two_ members.
if start_location > last_pos {
let slice = locator.slice_source_code_range(&Range::new(last_pos, start_location));
let slice = locator.slice(&Range::new(last_pos, start_location));
output.push_str(slice);
}
@ -159,7 +159,7 @@ pub fn remove_import_members(contents: &str, members: &[&str]) -> String {
}
// Add the remaining content.
let slice = locator.slice_source_code_at(last_pos);
let slice = locator.skip(last_pos);
output.push_str(slice);
output
}

2
crates/ruff/src/rules/pyupgrade/rules/extraneous_parentheses.rs
View file

@ -139,7 +139,7 @@ pub fn extraneous_parentheses(
if matches!(autofix, flags::Autofix::Enabled)
&& settings.rules.should_fix(&Rule::ExtraneousParentheses)
{
let contents = locator.slice_source_code_range(&Range::new(*start, *end));
let contents = locator.slice(&Range::new(*start, *end));
diagnostic.amend(Fix::replacement(
contents[1..contents.len() - 1].to_string(),
*start,

16
crates/ruff/src/rules/pyupgrade/rules/f_strings.rs
View file

@ -46,9 +46,7 @@ impl<'a> FormatSummaryValues<'a> {
let mut extracted_kwargs: FxHashMap<&str, String> = FxHashMap::default();
if let ExprKind::Call { args, keywords, .. } = &expr.node {
for arg in args {
let arg = checker
.locator
.slice_source_code_range(&Range::from_located(arg));
let arg = checker.locator.slice(&Range::from_located(arg));
if contains_invalids(arg) {
return None;
}
@ -57,9 +55,7 @@ impl<'a> FormatSummaryValues<'a> {
for keyword in keywords {
let KeywordData { arg, value } = &keyword.node;
if let Some(key) = arg {
let kwarg = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let kwarg = checker.locator.slice(&Range::from_located(value));
if contains_invalids(kwarg) {
return None;
}
@ -130,9 +126,7 @@ fn try_convert_to_f_string(checker: &Checker, expr: &Expr) -> Option<String> {
return None;
};
let contents = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let contents = checker.locator.slice(&Range::from_located(value));
// Tokenize: we need to avoid trying to fix implicit string concatenations.
if lexer::make_tokenizer(contents)
@ -265,9 +259,7 @@ pub(crate) fn f_strings(checker: &mut Checker, summary: &FormatSummary, expr: &E
};
// Avoid refactors that increase the resulting string length.
let existing = checker
.locator
.slice_source_code_range(&Range::from_located(expr));
let existing = checker.locator.slice(&Range::from_located(expr));
if contents.len() > existing.len() {
return;
}

2
crates/ruff/src/rules/pyupgrade/rules/format_literals.rs
View file

@ -86,7 +86,7 @@ fn generate_call(
locator: &Locator,
stylist: &Stylist,
) -> Result<String> {
let module_text = locator.slice_source_code_range(&Range::from_located(expr));
let module_text = locator.slice(&Range::from_located(expr));
let mut expression = match_expression(module_text)?;
let mut call = match_call(&mut expression)?;

3
crates/ruff/src/rules/pyupgrade/rules/import_replacements.rs
View file

@ -354,8 +354,7 @@ impl<'a> ImportReplacer<'a> {
let matched = ImportReplacer::format_import_from(&matched_names, target);
let unmatched = fixes::remove_import_members(
self.locator
.slice_source_code_range(&Range::from_located(self.stmt)),
self.locator.slice(&Range::from_located(self.stmt)),
&matched_names
.iter()
.map(|name| name.name.as_str())

4
crates/ruff/src/rules/pyupgrade/rules/native_literals.rs
View file

@ -117,9 +117,7 @@ pub fn native_literals(
// rust-python merges adjacent string/bytes literals into one node, but we can't
// safely remove the outer call in this situation. We're following pyupgrade
// here and skip.
let arg_code = checker
.locator
.slice_source_code_range(&Range::from_located(arg));
let arg_code = checker.locator.slice(&Range::from_located(arg));
if lexer::make_tokenizer(arg_code)
.flatten()
.filter(|(_, tok, _)| matches!(tok, Tok::String { .. }))

11
crates/ruff/src/rules/pyupgrade/rules/outdated_version_block.rs
View file

@ -57,7 +57,7 @@ fn metadata<T>(locator: &Locator, located: &Located<T>) -> Option<BlockMetadata>
// Start the selection at the start-of-line. This ensures consistent indentation
// in the token stream, in the event that the entire block is indented.
let text = locator.slice_source_code_range(&Range::new(
let text = locator.slice(&Range::new(
Location::new(located.location.row(), 0),
located.end_location.unwrap(),
));
@ -203,7 +203,7 @@ fn fix_py2_block(
Some(Fix::replacement(
checker
.locator
.slice_source_code_range(&Range::new(start.location, end.end_location.unwrap()))
.slice(&Range::new(start.location, end.end_location.unwrap()))
.to_string(),
stmt.location,
stmt.end_location.unwrap(),
@ -270,10 +270,7 @@ fn fix_py3_block(
Some(Fix::replacement(
checker
.locator
.slice_source_code_range(&Range::new(
start.location,
end.end_location.unwrap(),
))
.slice(&Range::new(start.location, end.end_location.unwrap()))
.to_string(),
stmt.location,
stmt.end_location.unwrap(),
@ -305,7 +302,7 @@ fn fix_py3_block(
// Replace the `elif` with an `else, preserve the body of the elif, and remove
// the rest.
let end = body.last().unwrap();
let text = checker.locator.slice_source_code_range(&Range::new(
let text = checker.locator.slice(&Range::new(
test.end_location.unwrap(),
end.end_location.unwrap(),
));

36
crates/ruff/src/rules/pyupgrade/rules/printf_string_formatting.rs
View file

@ -142,7 +142,7 @@ fn percent_to_format(format_string: &CFormatString) -> String {
fn clean_params_tuple(checker: &mut Checker, right: &Expr) -> String {
let mut contents = checker
.locator
.slice_source_code_range(&Range::from_located(right))
.slice(&Range::from_located(right))
.to_string();
if let ExprKind::Tuple { elts, .. } = &right.node {
if elts.len() == 1 {
@ -196,9 +196,7 @@ fn clean_params_dictionary(checker: &mut Checker, right: &Expr) -> Option<String
}
}
let value_string = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let value_string = checker.locator.slice(&Range::from_located(value));
arguments.push(format!("{key_string}={value_string}"));
} else {
// If there are any non-string keys, abort.
@ -206,9 +204,7 @@ fn clean_params_dictionary(checker: &mut Checker, right: &Expr) -> Option<String
}
}
None => {
let value_string = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let value_string = checker.locator.slice(&Range::from_located(value));
arguments.push(format!("**{value_string}"));
}
}
@ -324,9 +320,7 @@ pub(crate) fn printf_string_formatting(
let mut strings: Vec<(Location, Location)> = vec![];
let mut extension = None;
for (start, tok, end) in lexer::make_tokenizer_located(
checker
.locator
.slice_source_code_range(&Range::from_located(expr)),
checker.locator.slice(&Range::from_located(expr)),
expr.location,
)
.flatten()
@ -350,9 +344,7 @@ pub(crate) fn printf_string_formatting(
// Parse each string segment.
let mut format_strings = vec![];
for (start, end) in &strings {
let string = checker
.locator
.slice_source_code_range(&Range::new(*start, *end));
let string = checker.locator.slice(&Range::new(*start, *end));
let (Some(leader), Some(trailer)) = (leading_quote(string), trailing_quote(string)) else {
return;
};
@ -390,18 +382,10 @@ pub(crate) fn printf_string_formatting(
// Add the content before the string segment.
match prev {
None => {
contents.push_str(
checker
.locator
.slice_source_code_range(&Range::new(expr.location, *start)),
);
contents.push_str(checker.locator.slice(&Range::new(expr.location, *start)));
}
Some(prev) => {
contents.push_str(
checker
.locator
.slice_source_code_range(&Range::new(prev, *start)),
);
contents.push_str(checker.locator.slice(&Range::new(prev, *start)));
}
}
// Add the string itself.
@ -410,11 +394,7 @@ pub(crate) fn printf_string_formatting(
}
if let Some((.., end)) = extension {
contents.push_str(
checker
.locator
.slice_source_code_range(&Range::new(prev.unwrap(), end)),
);
contents.push_str(checker.locator.slice(&Range::new(prev.unwrap(), end)));
}
// Add the `.format` call.

3
crates/ruff/src/rules/pyupgrade/rules/redundant_open_modes.rs
View file

@ -135,8 +135,7 @@ fn create_check(
}
fn create_remove_param_fix(locator: &Locator, expr: &Expr, mode_param: &Expr) -> Result<Fix> {
let content =
locator.slice_source_code_range(&Range::new(expr.location, expr.end_location.unwrap()));
let content = locator.slice(&Range::new(expr.location, expr.end_location.unwrap()));
// Find the last comma before mode_param and create a deletion fix
// starting from the comma and ending after mode_param.
let mut fix_start: Option<Location> = None;

6
crates/ruff/src/rules/pyupgrade/rules/replace_stdout_stderr.rs
View file

@ -80,9 +80,9 @@ fn generate_fix(
stderr
};
let mut contents = String::from("capture_output=True");
if let Some(middle) = extract_middle(
locator.slice_source_code_range(&Range::new(first.end_location.unwrap(), last.location)),
) {
if let Some(middle) =
extract_middle(locator.slice(&Range::new(first.end_location.unwrap(), last.location)))
{
if middle.multi_line {
let Some(indent) = indentation(locator, first) else {
return None;

4
crates/ruff/src/rules/pyupgrade/rules/rewrite_c_element_tree.rs
View file

@ -24,9 +24,7 @@ impl AlwaysAutofixableViolation for RewriteCElementTree {
fn add_check_for_node<T>(checker: &mut Checker, node: &Located<T>) {
let mut diagnostic = Diagnostic::new(RewriteCElementTree, Range::from_located(node));
if checker.patch(diagnostic.kind.rule()) {
let contents = checker
.locator
.slice_source_code_range(&Range::from_located(node));
let contents = checker.locator.slice(&Range::from_located(node));
diagnostic.amend(Fix::replacement(
contents.replacen("cElementTree", "ElementTree", 1),
node.location,

4
crates/ruff/src/rules/pyupgrade/rules/rewrite_mock_import.rs
View file

@ -143,7 +143,7 @@ fn format_import(
locator: &Locator,
stylist: &Stylist,
) -> Result<String> {
let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
let module_text = locator.slice(&Range::from_located(stmt));
let mut tree = match_module(module_text)?;
let mut import = match_import(&mut tree)?;
@ -177,7 +177,7 @@ fn format_import_from(
locator: &Locator,
stylist: &Stylist,
) -> Result<String> {
let module_text = locator.slice_source_code_range(&Range::from_located(stmt));
let module_text = locator.slice(&Range::from_located(stmt));
let mut tree = match_module(module_text).unwrap();
let mut import = match_import_from(&mut tree)?;

4
crates/ruff/src/rules/pyupgrade/rules/rewrite_yield_from.rs
View file

@ -174,9 +174,7 @@ pub fn rewrite_yield_from(checker: &mut Checker, stmt: &Stmt) {
let mut diagnostic = Diagnostic::new(RewriteYieldFrom, Range::from_located(item.stmt));
if checker.patch(diagnostic.kind.rule()) {
let contents = checker
.locator
.slice_source_code_range(&Range::from_located(item.iter));
let contents = checker.locator.slice(&Range::from_located(item.iter));
let contents = format!("yield from {contents}");
diagnostic.amend(Fix::replacement(
contents,

2
crates/ruff/src/rules/pyupgrade/rules/unnecessary_encode_utf8.rs
View file

@ -100,7 +100,7 @@ fn replace_with_bytes_literal(
) -> Diagnostic {
let mut diagnostic = Diagnostic::new(UnnecessaryEncodeUTF8, Range::from_located(expr));
if patch {
let content = locator.slice_source_code_range(&Range::new(
let content = locator.slice(&Range::new(
constant.location,
constant.end_location.unwrap(),
));

4
crates/ruff/src/rules/pyupgrade/rules/unpack_list_comprehension.rs
View file

@ -97,9 +97,7 @@ pub fn unpack_list_comprehension(checker: &mut Checker, targets: &[Expr], value:
let mut diagnostic =
Diagnostic::new(RewriteListComprehension, Range::from_located(value));
if checker.patch(diagnostic.kind.rule()) {
let existing = checker
.locator
.slice_source_code_range(&Range::from_located(value));
let existing = checker.locator.slice(&Range::from_located(value));
let mut content = String::with_capacity(existing.len());
content.push('(');

2
crates/ruff/src/rules/ruff/rules/ambiguous_unicode_character.rs
View file

@ -1693,7 +1693,7 @@ pub fn ambiguous_unicode_character(
) -> Vec<Diagnostic> {
let mut diagnostics = vec![];
let text = locator.slice_source_code_range(&Range::new(start, end));
let text = locator.slice(&Range::new(start, end));
let mut col_offset = 0;
let mut row_offset = 0;

26
crates/ruff/src/source_code/locator.rs
View file

@ -104,42 +104,28 @@ impl<'a> Locator<'a> {
self.index.get_or_init(|| index(self.contents))
}
pub fn slice_source_code_until(&self, location: Location) -> &'a str {
/// Take the source code up to the given [`Location`].
pub fn take(&self, location: Location) -> &'a str {
let index = self.get_or_init_index();
let offset = truncate(location, index, self.contents);
&self.contents[..offset]
}
pub fn slice_source_code_at(&self, location: Location) -> &'a str {
/// Take the source code after the given [`Location`].
pub fn skip(&self, location: Location) -> &'a str {
let index = self.get_or_init_index();
let offset = truncate(location, index, self.contents);
&self.contents[offset..]
}
pub fn slice_source_code_range(&self, range: &Range) -> &'a str {
/// Take the source code between the given [`Range`].
pub fn slice(&self, range: &Range) -> &'a str {
let index = self.get_or_init_index();
let start = truncate(range.location, index, self.contents);
let end = truncate(range.end_location, index, self.contents);
&self.contents[start..end]
}
pub fn partition_source_code_at(
&self,
outer: &Range,
inner: &Range,
) -> (&'a str, &'a str, &'a str) {
let index = self.get_or_init_index();
let outer_start = truncate(outer.location, index, self.contents);
let outer_end = truncate(outer.end_location, index, self.contents);
let inner_start = truncate(inner.location, index, self.contents);
let inner_end = truncate(inner.end_location, index, self.contents);
(
&self.contents[outer_start..inner_start],
&self.contents[inner_start..inner_end],
&self.contents[inner_end..outer_end],
)
}
pub const fn len(&self) -> usize {
self.contents.len()
}

4
crates/ruff/src/source_code/stylist.rs
View file

@ -168,7 +168,7 @@ fn detect_indentation(contents: &str, locator: &Locator) -> Option<Indentation>
for (_start, tok, end) in lexer::make_tokenizer(contents).flatten() {
if let Tok::Indent { .. } = tok {
let start = Location::new(end.row(), 0);
let whitespace = locator.slice_source_code_range(&Range::new(start, end));
let whitespace = locator.slice(&Range::new(start, end));
return Some(Indentation(whitespace.to_string()));
}
}
@ -179,7 +179,7 @@ fn detect_indentation(contents: &str, locator: &Locator) -> Option<Indentation>
fn detect_quote(contents: &str, locator: &Locator) -> Option<Quote> {
for (start, tok, end) in lexer::make_tokenizer(contents).flatten() {
if let Tok::String { .. } = tok {
let content = locator.slice_source_code_range(&Range::new(start, end));
let content = locator.slice(&Range::new(start, end));
if let Some(pattern) = leading_quote(content) {
if pattern.contains('\'') {
return Some(Quote::Single);

37
crates/ruff_python_formatter/src/core/locator.rs
View file

@ -108,46 +108,11 @@ impl<'a> Locator<'a> {
self.index.get_or_init(|| index(self.contents))
}
pub fn slice_source_code_until(&self, location: Location) -> &'a str {
let index = self.get_or_init_index();
let offset = truncate(location, index, self.contents);
&self.contents[..offset]
}
pub fn slice_source_code_at(&self, location: Location) -> &'a str {
let index = self.get_or_init_index();
let offset = truncate(location, index, self.contents);
&self.contents[offset..]
}
pub fn slice_source_code_range(&self, range: &Range) -> &'a str {
let index = self.get_or_init_index();
let start = truncate(range.location, index, self.contents);
let end = truncate(range.end_location, index, self.contents);
&self.contents[start..end]
}
/// Slice the source code at a [`Range`].
pub fn slice(&self, range: Range) -> (Rc<str>, usize, usize) {
let index = self.get_or_init_index();
let start = truncate(range.location, index, self.contents);
let end = truncate(range.end_location, index, self.contents);
(Rc::clone(&self.contents_rc), start, end)
}
pub fn partition_source_code_at(
&self,
outer: &Range,
inner: &Range,
) -> (&'a str, &'a str, &'a str) {
let index = self.get_or_init_index();
let outer_start = truncate(outer.location, index, self.contents);
let outer_end = truncate(outer.end_location, index, self.contents);
let inner_start = truncate(inner.location, index, self.contents);
let inner_end = truncate(inner.end_location, index, self.contents);
(
&self.contents[outer_start..inner_start],
&self.contents[inner_start..inner_end],
&self.contents[inner_end..outer_end],
)
}
}