Implement From<Located> for Range (#3377)

crates/ruff_python_ast/src/helpers.rs

@@ -799,7 +799,7 @@ where
         match &stmt.node {
             StmtKind::Raise { exc, cause } => {
                 self.raises
-                    .push((Range::from_located(stmt), exc.as_deref(), cause.as_deref()));
+                    .push((Range::from(stmt), exc.as_deref(), cause.as_deref()));
             }
             StmtKind::ClassDef { .. }
             | StmtKind::FunctionDef { .. }
@@ -940,7 +940,7 @@ pub fn identifier_range(stmt: &Stmt, locator: &Locator) -> Range {
             | StmtKind::FunctionDef { .. }
             | StmtKind::AsyncFunctionDef { .. }
     ) {
-        let contents = locator.slice(Range::from_located(stmt));
+        let contents = locator.slice(stmt);
         for (start, tok, end) in lexer::lex_located(contents, Mode::Module, stmt.location).flatten()
         {
             if matches!(tok, Tok::Name { .. }) {
@@ -949,7 +949,7 @@ pub fn identifier_range(stmt: &Stmt, locator: &Locator) -> Range {
         }
         error!("Failed to find identifier for {:?}", stmt);
     }
-    Range::from_located(stmt)
+    Range::from(stmt)
 }
 
 /// Like `identifier_range`, but accepts a `Binding`.
@@ -967,12 +967,12 @@ pub fn binding_range(binding: &Binding, locator: &Locator) -> Range {
     }
 }
 
-// Return the ranges of `Name` tokens within a specified node.
-pub fn find_names<'a, T, U>(
-    located: &'a Located<T, U>,
+/// Return the ranges of [`Tok::Name`] tokens within a specified node.
+pub fn find_names<'a, T>(
+    located: &'a Located<T>,
     locator: &'a Locator,
 ) -> impl Iterator<Item = Range> + 'a {
-    let contents = locator.slice(Range::from_located(located));
+    let contents = locator.slice(located);
     lexer::lex_located(contents, Mode::Module, located.location)
         .flatten()
         .filter(|(_, tok, _)| matches!(tok, Tok::Name { .. }))
@@ -1031,7 +1031,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(Range::from_located(expr));
+    let contents = locator.slice(expr);
     lexer::lex_located(contents, Mode::Module, expr.location)
         .flatten()
         .filter_map(|(location, tok, end_location)| match tok {

crates/ruff_python_ast/src/source_code/locator.rs

@@ -125,8 +125,9 @@ impl<'a> Locator<'a> {
     }
 
     /// Take the source code between the given [`Range`].
-    pub fn slice(&self, range: Range) -> &'a str {
+    pub fn slice<R: Into<Range>>(&self, range: R) -> &'a str {
         let index = self.get_or_init_index();
+        let range = range.into();
         let start = truncate(range.location, index, self.contents);
         let end = truncate(range.end_location, index, self.contents);
         &self.contents[start..end]

crates/ruff_python_ast/src/types.rs

@@ -28,13 +28,17 @@ impl Range {
             end_location,
         }
     }
+}
 
-    pub fn from_located<T, U>(located: &Located<T, U>) -> Self {
+impl<T> From<&Located<T>> for Range {
+    fn from(located: &Located<T>) -> Self {
         Range::new(located.location, located.end_location.unwrap())
     }
+}
 
-    pub fn contains(&self, other: &Range) -> bool {
-        self.location <= other.location && self.end_location >= other.end_location
+impl<T> From<&Box<Located<T>>> for Range {
+    fn from(located: &Box<Located<T>>) -> Self {
+        Range::new(located.location, located.end_location.unwrap())
     }
 }
 

crates/ruff_python_ast/src/whitespace.rs

@@ -7,7 +7,7 @@ use crate::types::Range;
 
 /// 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 range = Range::from(located);
     let indentation = locator.slice(Range::new(
         Location::new(range.location.row(), 0),
         Location::new(range.location.row(), range.location.column()),