Bump version to 0.0.173

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.171
+    rev: v0.0.173
     hooks:
       - id: ruff
 

Cargo.lock

@@ -724,7 +724,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.171-dev.0"
+version = "0.0.173-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1821,7 +1821,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.171"
+version = "0.0.173"
 dependencies = [
  "annotate-snippets 0.9.1",
  "anyhow",
@@ -1874,7 +1874,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_dev"
-version = "0.0.171"
+version = "0.0.173"
 dependencies = [
  "anyhow",
  "clap 4.0.29",
@@ -1892,7 +1892,7 @@ dependencies = [
 
 [[package]]
 name = "ruff_macros"
-version = "0.0.171"
+version = "0.0.173"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -6,7 +6,7 @@ members = [
 
 [package]
 name = "ruff"
-version = "0.0.171"
+version = "0.0.173"
 edition = "2021"
 rust-version = "1.65.0"
 
@@ -41,7 +41,7 @@ quick-junit = { version = "0.3.2" }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 ropey = { version = "1.5.0", features = ["cr_lines", "simd"], default-features = false }
-ruff_macros = { version = "0.0.171", path = "ruff_macros" }
+ruff_macros = { version = "0.0.173", path = "ruff_macros" }
 rustc-hash = { version = "1.1.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }
 rustpython-common = { git = "https://github.com/RustPython/RustPython.git", rev = "28f9f65ccc625f00835d84bbb5fba274dce5aa89" }

README.md

@@ -147,7 +147,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.171
+    rev: v0.0.173
     hooks:
       - id: ruff
 ```
@@ -438,11 +438,13 @@ For more, see [Pyflakes](https://pypi.org/project/pyflakes/2.5.0/) on PyPI.
 | F706 | ReturnOutsideFunction | `return` statement outside of a function/method |  |
 | F707 | DefaultExceptNotLast | An `except` block as not the last exception handler |  |
 | F722 | ForwardAnnotationSyntaxError | Syntax error in forward annotation: `...` |  |
+| F811 | RedefinedWhileUnused | Redefinition of unused `...` from line 1 |  |
 | F821 | UndefinedName | Undefined name `...` |  |
 | F822 | UndefinedExport | Undefined name `...` in `__all__` |  |
 | F823 | UndefinedLocal | Local variable `...` referenced before assignment |  |
 | F831 | DuplicateArgumentName | Duplicate argument name in function definition |  |
 | F841 | UnusedVariable | Local variable `...` is assigned to but never used |  |
+| F842 | UnusedAnnotation | Local variable `...` is annotated but never used |  |
 | F901 | RaiseNotImplemented | `raise NotImplemented` should be `raise NotImplementedError` | 🛠 |
 
 ### pycodestyle (E, W)
@@ -515,6 +517,7 @@ For more, see [pydocstyle](https://pypi.org/project/pydocstyle/6.1.1/) on PyPI.
 | D214 | SectionNotOverIndented | Section is over-indented ("Returns") | 🛠 |
 | D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") | 🛠 |
 | D300 | UsesTripleQuotes | Use """triple double quotes""" |  |
+| D301 | UsesRPrefixForBackslashedContent | Use r""" if any backslashes in a docstring |  |
 | D400 | EndsInPeriod | First line should end with a period | 🛠 |
 | D402 | NoSignature | First line should not be the function's signature |  |
 | D403 | FirstLineCapitalized | First word of the first line should be properly capitalized |  |
@@ -1980,6 +1983,10 @@ from .utils import (
 )
 ```
 
+Note that this setting is only effective when combined with `combine-as-imports = true`.
+When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+own line, in which case, wrapping is not necessary.
+
 **Default value**: `false`
 
 **Type**: `bool`
@@ -1989,6 +1996,7 @@ from .utils import (
 ```toml
 [tool.ruff.isort]
 force-wrap-aliases = true
+combine-as-imports = true
 ```
 
 ---

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.171"
+version = "0.0.173"
 dependencies = [
  "anyhow",
  "clap",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.171"
+version = "0.0.173"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.171-dev.0"
+version = "0.0.173-dev.0"
 edition = "2021"
 
 [lib]

flake8_to_ruff/src/converter.rs

@@ -512,6 +512,7 @@ mod tests {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D403,
                 CheckCodePrefix::D404,

flake8_to_ruff/src/plugin.rs

@@ -162,6 +162,7 @@ impl DocstringConvention {
                 // CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -209,6 +210,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 CheckCodePrefix::D400,
                 // CheckCodePrefix::D402,
                 CheckCodePrefix::D403,
@@ -257,6 +259,7 @@ impl DocstringConvention {
                 CheckCodePrefix::D214,
                 // CheckCodePrefix::D215,
                 CheckCodePrefix::D300,
+                CheckCodePrefix::D301,
                 // CheckCodePrefix::D400,
                 CheckCodePrefix::D402,
                 CheckCodePrefix::D403,

resources/test/fixtures/flake8_return/RET504.py

@@ -130,6 +130,12 @@ def x():
     return val
 
 
+def x():
+    a = 1
+    print(f"a={a}")
+    return a
+
+
 # Test cases for using value for assignment then returning it
 # See:https://github.com/afonasev/flake8-return/issues/47
 def resolve_from_url(self, url: str) -> dict:

resources/test/fixtures/pyflakes/F842.py

@@ -0,0 +1,13 @@
+def f():
+    name: str
+    age: int
+
+
+class A:
+    name: str
+    age: int
+
+
+class B:
+    name: str = "Bob"
+    age: int = 18

ruff_dev/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_dev"
-version = "0.0.171"
+version = "0.0.173"
 edition = "2021"
 
 [dependencies]

ruff_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff_macros"
-version = "0.0.171"
+version = "0.0.173"
 edition = "2021"
 
 [lib]

src/ast/types.rs

@@ -73,7 +73,11 @@ pub struct Scope<'a> {
     pub kind: ScopeKind<'a>,
     pub import_starred: bool,
     pub uses_locals: bool,
+    /// A map from bound name to binding index.
     pub values: FxHashMap<&'a str, usize>,
+    /// A list of (name, index) pairs for bindings that were overridden in the
+    /// scope.
+    pub overridden: Vec<(&'a str, usize)>,
 }
 
 impl<'a> Scope<'a> {
@@ -84,6 +88,7 @@ impl<'a> Scope<'a> {
             import_starred: false,
             uses_locals: false,
             values: FxHashMap::default(),
+            overridden: Vec::new(),
         }
     }
 }
@@ -117,8 +122,6 @@ pub struct Binding<'a> {
     /// Tuple of (scope index, range) indicating the scope and range at which
     /// the binding was last used.
     pub used: Option<(usize, Range)>,
-    /// A list of pointers to `Binding` instances that redefined this binding.
-    pub redefined: Vec<usize>,
 }
 
 // Pyflakes defines the following binding hierarchy (via inheritance):

src/ast/whitespace.rs

@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::str::Lines;
 
 use rustpython_ast::{Located, Location};
@@ -5,31 +6,26 @@ use rustpython_ast::{Located, Location};
 use crate::ast::types::Range;
 use crate::check_ast::Checker;
 
+/// Extract the leading indentation from a line.
+pub fn indentation<'a, T>(checker: &'a Checker, located: &'a Located<T>) -> Cow<'a, str> {
+    let range = Range::from_located(located);
+    checker.locator.slice_source_code_range(&Range {
+        location: Location::new(range.location.row(), 0),
+        end_location: Location::new(range.location.row(), range.location.column()),
+    })
+}
+
 /// Extract the leading words from a line of text.
-pub fn leading_words(line: &str) -> String {
-    line.trim()
-        .chars()
-        .take_while(|char| char.is_alphanumeric() || char.is_whitespace())
-        .collect()
+pub fn leading_words(line: &str) -> &str {
+    let line = line.trim();
+    line.find(|char: char| !char.is_alphanumeric() && !char.is_whitespace())
+        .map_or(line, |index| &line[..index])
 }
 
 /// Extract the leading whitespace from a line of text.
-pub fn leading_space(line: &str) -> String {
-    line.chars()
-        .take_while(|char| char.is_whitespace())
-        .collect()
-}
-
-/// Extract the leading indentation from a line.
-pub fn indentation<T>(checker: &Checker, located: &Located<T>) -> String {
-    let range = Range::from_located(located);
-    checker
-        .locator
-        .slice_source_code_range(&Range {
-            location: Location::new(range.location.row(), 0),
-            end_location: Location::new(range.location.row(), range.location.column()),
-        })
-        .to_string()
+pub fn leading_space(line: &str) -> &str {
+    line.find(|char: char| !char.is_whitespace())
+        .map_or(line, |index| &line[..index])
 }
 
 /// Replace any non-whitespace characters from an indentation string.

src/check_ast.rs

@@ -4,7 +4,9 @@ use std::path::Path;
 
 use itertools::Itertools;
 use log::error;
+use nohash_hasher::IntMap;
 use rustc_hash::{FxHashMap, FxHashSet};
+use rustpython_ast::Location;
 use rustpython_parser::ast::{
     Arg, Arguments, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprContext, ExprKind,
     KeywordData, Operator, Stmt, StmtKind, Suite,
@@ -22,7 +24,7 @@ use crate::ast::types::{
 use crate::ast::visitor::{walk_excepthandler, Visitor};
 use crate::ast::{branch_detection, cast, helpers, operations, visitor};
 use crate::checks::{Check, CheckCode, CheckKind, DeferralKeyword};
-use crate::docstrings::definition::{Definition, DefinitionKind, Documentable};
+use crate::docstrings::definition::{Definition, DefinitionKind, Docstring, Documentable};
 use crate::python::builtins::{BUILTINS, MAGIC_GLOBALS};
 use crate::python::future::ALL_FEATURE_NAMES;
 use crate::python::typing;
@@ -67,6 +69,7 @@ pub struct Checker<'a> {
     pub(crate) depths: FxHashMap<RefEquality<'a, Stmt>, usize>,
     pub(crate) child_to_parent: FxHashMap<RefEquality<'a, Stmt>, RefEquality<'a, Stmt>>,
     pub(crate) bindings: Vec<Binding<'a>>,
+    pub(crate) redefinitions: IntMap<usize, Vec<usize>>,
     scopes: Vec<Scope<'a>>,
     scope_stack: Vec<usize>,
     dead_scopes: Vec<usize>,
@@ -113,6 +116,7 @@ impl<'a> Checker<'a> {
             depths: FxHashMap::default(),
             child_to_parent: FxHashMap::default(),
             bindings: vec![],
+            redefinitions: IntMap::default(),
             scopes: vec![],
             scope_stack: vec![],
             dead_scopes: vec![],
@@ -249,7 +253,6 @@ where
                                 used: None,
                                 range: Range::from_located(stmt),
                                 source: None,
-                                redefined: vec![],
                             });
                             self.scopes[GLOBAL_SCOPE_INDEX].values.insert(name, index);
                         }
@@ -265,7 +268,6 @@ where
                             used: usage,
                             range: Range::from_located(stmt),
                             source: None,
-                            redefined: vec![],
                         });
                         scope.values.insert(name, index);
                     }
@@ -296,7 +298,6 @@ where
                             used: usage,
                             range: Range::from_located(stmt),
                             source: None,
-                            redefined: vec![],
                         });
                         scope.values.insert(name, index);
                     }
@@ -512,7 +513,6 @@ where
                         used: None,
                         range: Range::from_located(stmt),
                         source: Some(self.current_parent().clone()),
-                        redefined: vec![],
                     },
                 );
             }
@@ -622,7 +622,6 @@ where
                                 used: None,
                                 range: Range::from_located(alias),
                                 source: Some(self.current_parent().clone()),
-                                redefined: vec![],
                             },
                         );
                     } else {
@@ -663,7 +662,6 @@ where
                                 },
                                 range: Range::from_located(alias),
                                 source: Some(self.current_parent().clone()),
-                                redefined: vec![],
                             },
                         );
                     }
@@ -808,7 +806,6 @@ where
                                 )),
                                 range: Range::from_located(alias),
                                 source: Some(self.current_parent().clone()),
-                                redefined: vec![],
                             },
                         );
 
@@ -840,7 +837,6 @@ where
                                 used: None,
                                 range: Range::from_located(stmt),
                                 source: Some(self.current_parent().clone()),
-                                redefined: vec![],
                             },
                         );
 
@@ -910,7 +906,6 @@ where
                                 },
                                 range,
                                 source: Some(self.current_parent().clone()),
-                                redefined: vec![],
                             },
                         );
                     }
@@ -1236,7 +1231,6 @@ where
                     used: None,
                     range: Range::from_located(stmt),
                     source: Some(self.current_parent().clone()),
-                    redefined: vec![],
                 },
             );
         };
@@ -2283,7 +2277,6 @@ where
                     self.in_subscript = true;
                     visitor::walk_expr(self, expr);
                 } else {
-                    self.in_subscript = true;
                     match typing::match_annotated_subscript(
                         value,
                         &self.from_imports,
@@ -2303,8 +2296,7 @@ where
                                 // Ex) Annotated[int, "Hello, world!"]
                                 SubscriptKind::PEP593AnnotatedSubscript => {
                                     // First argument is a type (including forward references); the
-                                    // rest are arbitrary Python
-                                    // objects.
+                                    // rest are arbitrary Python objects.
                                     self.visit_expr(value);
                                     if let ExprKind::Tuple { elts, ctx } = &slice.node {
                                         if let Some(expr) = elts.first() {
@@ -2499,7 +2491,6 @@ where
                 used: None,
                 range: Range::from_located(arg),
                 source: Some(self.current_parent().clone()),
-                redefined: vec![],
             },
         );
 
@@ -2565,7 +2556,6 @@ impl<'a> Checker<'a> {
                 range: Range::default(),
                 used: None,
                 source: None,
-                redefined: vec![],
             });
             scope.values.insert(builtin, index);
         }
@@ -2594,8 +2584,9 @@ impl<'a> Checker<'a> {
     where
         'b: 'a,
     {
-        let index = self.bindings.len();
+        let binding_index = self.bindings.len();
 
+        let mut overridden = None;
         if let Some((stack_index, scope_index)) = self
             .scope_stack
             .iter()
@@ -2603,8 +2594,8 @@ impl<'a> Checker<'a> {
             .enumerate()
             .find(|(_, scope_index)| self.scopes[**scope_index].values.contains_key(&name))
         {
-            let existing_index = self.scopes[*scope_index].values.get(&name).unwrap();
-            let existing = &self.bindings[*existing_index];
+            let existing_binding_index = self.scopes[*scope_index].values.get(&name).unwrap();
+            let existing = &self.bindings[*existing_binding_index];
             let in_current_scope = stack_index == 0;
             if !matches!(existing.kind, BindingKind::Builtin)
                 && existing.source.as_ref().map_or(true, |left| {
@@ -2627,6 +2618,7 @@ impl<'a> Checker<'a> {
                         | BindingKind::FutureImportation
                 );
                 if matches!(binding.kind, BindingKind::LoopVar) && existing_is_import {
+                    overridden = Some((*scope_index, *existing_binding_index));
                     if self.settings.enabled.contains(&CheckCode::F402) {
                         self.add_check(Check::new(
                             CheckKind::ImportShadowedByLoopVar(
@@ -2646,6 +2638,7 @@ impl<'a> Checker<'a> {
                                 cast::decorator_list(existing.source.as_ref().unwrap().0),
                             ))
                     {
+                        overridden = Some((*scope_index, *existing_binding_index));
                         if self.settings.enabled.contains(&CheckCode::F811) {
                             self.add_check(Check::new(
                                 CheckKind::RedefinedWhileUnused(
@@ -2657,13 +2650,22 @@ impl<'a> Checker<'a> {
                         }
                     }
                 } else if existing_is_import && binding.redefines(existing) {
-                    self.bindings[*existing_index].redefined.push(index);
+                    self.redefinitions
+                        .entry(*existing_binding_index)
+                        .or_insert_with(Vec::new)
+                        .push(binding_index);
                 }
             }
         }
 
-        // TODO(charlie): Don't treat annotations as assignments if there is an existing
-        // value.
+        // If we're about to lose the binding, store it as overriden.
+        if let Some((scope_index, binding_index)) = overridden {
+            self.scopes[scope_index]
+                .overridden
+                .push((name, binding_index));
+        }
+
+        // Assume the rebound name is used as a global or within a loop.
         let scope = self.current_scope();
         let binding = match scope.values.get(&name) {
             None => binding,
@@ -2673,10 +2675,14 @@ impl<'a> Checker<'a> {
             },
         };
 
-        self.bindings.push(binding);
-
+        // Don't treat annotations as assignments if there is an existing value
+        // in scope.
         let scope = &mut self.scopes[*(self.scope_stack.last().expect("No current scope found"))];
-        scope.values.insert(name, index);
+        if !(matches!(binding.kind, BindingKind::Annotation) && scope.values.contains_key(name)) {
+            scope.values.insert(name, binding_index);
+        }
+
+        self.bindings.push(binding);
     }
 
     fn handle_node_load(&mut self, expr: &Expr) {
@@ -2701,6 +2707,13 @@ impl<'a> Checker<'a> {
                     // Mark the binding as used.
                     self.bindings[*index].used = Some((scope_id, Range::from_located(expr)));
 
+                    if matches!(self.bindings[*index].kind, BindingKind::Annotation)
+                        && !self.in_deferred_string_type_definition
+                        && !self.in_deferred_type_definition
+                    {
+                        continue;
+                    }
+
                     // If the name of the sub-importation is the same as an alias of another
                     // importation and the alias is used, that sub-importation should be
                     // marked as used too.
@@ -2841,7 +2854,6 @@ impl<'a> Checker<'a> {
                     used: None,
                     range: Range::from_located(expr),
                     source: Some(self.current_parent().clone()),
-                    redefined: vec![],
                 },
             );
             return;
@@ -2859,7 +2871,6 @@ impl<'a> Checker<'a> {
                     used: None,
                     range: Range::from_located(expr),
                     source: Some(self.current_parent().clone()),
-                    redefined: vec![],
                 },
             );
             return;
@@ -2873,7 +2884,6 @@ impl<'a> Checker<'a> {
                     used: None,
                     range: Range::from_located(expr),
                     source: Some(self.current_parent().clone()),
-                    redefined: vec![],
                 },
             );
             return;
@@ -2924,7 +2934,6 @@ impl<'a> Checker<'a> {
                         used: None,
                         range: Range::from_located(expr),
                         source: Some(self.current_parent().clone()),
-                        redefined: vec![],
                     },
                 );
                 return;
@@ -2938,7 +2947,6 @@ impl<'a> Checker<'a> {
                 used: None,
                 range: Range::from_located(expr),
                 source: Some(self.current_parent().clone()),
-                redefined: vec![],
             },
         );
     }
@@ -3112,7 +3120,17 @@ impl<'a> Checker<'a> {
         while let Some((index, (scopes, _parents))) = self.deferred_assignments.pop() {
             if self.settings.enabled.contains(&CheckCode::F841) {
                 self.add_checks(
-                    pyflakes::checks::unused_variables(
+                    pyflakes::checks::unused_variable(
+                        &self.scopes[index],
+                        &self.bindings,
+                        &self.settings.dummy_variable_rgx,
+                    )
+                    .into_iter(),
+                );
+            }
+            if self.settings.enabled.contains(&CheckCode::F842) {
+                self.add_checks(
+                    pyflakes::checks::unused_annotation(
                         &self.scopes[index],
                         &self.bindings,
                         &self.settings.dummy_variable_rgx,
@@ -3184,6 +3202,9 @@ impl<'a> Checker<'a> {
                 }
             }
 
+            // Look for any bindings that were redefined in another scope, and remain unused.
+            // Note that we only store references in `redefinitions` if the bindings are in
+            // different scopes.
             if self.settings.enabled.contains(&CheckCode::F811) {
                 for (name, index) in &scope.values {
                     let binding = &self.bindings[*index];
@@ -3206,14 +3227,16 @@ impl<'a> Checker<'a> {
                             continue;
                         }
 
-                        for index in &binding.redefined {
-                            checks.push(Check::new(
-                                CheckKind::RedefinedWhileUnused(
-                                    (*name).to_string(),
-                                    binding.range.location.row(),
-                                ),
-                                self.bindings[*index].range,
-                            ));
+                        if let Some(indices) = self.redefinitions.get(index) {
+                            for index in indices {
+                                checks.push(Check::new(
+                                    CheckKind::RedefinedWhileUnused(
+                                        (*name).to_string(),
+                                        binding.range.location.row(),
+                                    ),
+                                    self.bindings[*index].range,
+                                ));
+                            }
                         }
                     }
                 }
@@ -3260,7 +3283,11 @@ impl<'a> Checker<'a> {
 
                 let mut unused: FxHashMap<BindingContext, Vec<UnusedImport>> = FxHashMap::default();
 
-                for (name, index) in &scope.values {
+                for (name, index) in scope
+                    .values
+                    .iter()
+                    .chain(scope.overridden.iter().map(|(a, b)| (a, b)))
+                {
                     let binding = &self.bindings[*index];
 
                     let (BindingKind::Importation(_, full_name)
@@ -3336,22 +3363,68 @@ impl<'a> Checker<'a> {
     }
 
     fn check_definitions(&mut self) {
+        let enforce_annotations = self.settings.enabled.contains(&CheckCode::ANN001)
+            || self.settings.enabled.contains(&CheckCode::ANN002)
+            || self.settings.enabled.contains(&CheckCode::ANN003)
+            || self.settings.enabled.contains(&CheckCode::ANN101)
+            || self.settings.enabled.contains(&CheckCode::ANN102)
+            || self.settings.enabled.contains(&CheckCode::ANN201)
+            || self.settings.enabled.contains(&CheckCode::ANN202)
+            || self.settings.enabled.contains(&CheckCode::ANN204)
+            || self.settings.enabled.contains(&CheckCode::ANN205)
+            || self.settings.enabled.contains(&CheckCode::ANN206)
+            || self.settings.enabled.contains(&CheckCode::ANN401);
+        let enforce_docstrings = self.settings.enabled.contains(&CheckCode::D100)
+            || self.settings.enabled.contains(&CheckCode::D101)
+            || self.settings.enabled.contains(&CheckCode::D102)
+            || self.settings.enabled.contains(&CheckCode::D103)
+            || self.settings.enabled.contains(&CheckCode::D104)
+            || self.settings.enabled.contains(&CheckCode::D105)
+            || self.settings.enabled.contains(&CheckCode::D106)
+            || self.settings.enabled.contains(&CheckCode::D107)
+            || self.settings.enabled.contains(&CheckCode::D200)
+            || self.settings.enabled.contains(&CheckCode::D201)
+            || self.settings.enabled.contains(&CheckCode::D202)
+            || self.settings.enabled.contains(&CheckCode::D203)
+            || self.settings.enabled.contains(&CheckCode::D204)
+            || self.settings.enabled.contains(&CheckCode::D205)
+            || self.settings.enabled.contains(&CheckCode::D206)
+            || self.settings.enabled.contains(&CheckCode::D207)
+            || self.settings.enabled.contains(&CheckCode::D208)
+            || self.settings.enabled.contains(&CheckCode::D209)
+            || self.settings.enabled.contains(&CheckCode::D210)
+            || self.settings.enabled.contains(&CheckCode::D211)
+            || self.settings.enabled.contains(&CheckCode::D212)
+            || self.settings.enabled.contains(&CheckCode::D213)
+            || self.settings.enabled.contains(&CheckCode::D214)
+            || self.settings.enabled.contains(&CheckCode::D215)
+            || self.settings.enabled.contains(&CheckCode::D300)
+            || self.settings.enabled.contains(&CheckCode::D301)
+            || self.settings.enabled.contains(&CheckCode::D400)
+            || self.settings.enabled.contains(&CheckCode::D402)
+            || self.settings.enabled.contains(&CheckCode::D403)
+            || self.settings.enabled.contains(&CheckCode::D404)
+            || self.settings.enabled.contains(&CheckCode::D405)
+            || self.settings.enabled.contains(&CheckCode::D406)
+            || self.settings.enabled.contains(&CheckCode::D407)
+            || self.settings.enabled.contains(&CheckCode::D408)
+            || self.settings.enabled.contains(&CheckCode::D409)
+            || self.settings.enabled.contains(&CheckCode::D410)
+            || self.settings.enabled.contains(&CheckCode::D411)
+            || self.settings.enabled.contains(&CheckCode::D412)
+            || self.settings.enabled.contains(&CheckCode::D413)
+            || self.settings.enabled.contains(&CheckCode::D414)
+            || self.settings.enabled.contains(&CheckCode::D415)
+            || self.settings.enabled.contains(&CheckCode::D416)
+            || self.settings.enabled.contains(&CheckCode::D417)
+            || self.settings.enabled.contains(&CheckCode::D418)
+            || self.settings.enabled.contains(&CheckCode::D419);
+
         let mut overloaded_name: Option<String> = None;
         self.definitions.reverse();
         while let Some((definition, visibility)) = self.definitions.pop() {
             // flake8-annotations
-            if self.settings.enabled.contains(&CheckCode::ANN001)
-                || self.settings.enabled.contains(&CheckCode::ANN002)
-                || self.settings.enabled.contains(&CheckCode::ANN003)
-                || self.settings.enabled.contains(&CheckCode::ANN101)
-                || self.settings.enabled.contains(&CheckCode::ANN102)
-                || self.settings.enabled.contains(&CheckCode::ANN201)
-                || self.settings.enabled.contains(&CheckCode::ANN202)
-                || self.settings.enabled.contains(&CheckCode::ANN204)
-                || self.settings.enabled.contains(&CheckCode::ANN205)
-                || self.settings.enabled.contains(&CheckCode::ANN206)
-                || self.settings.enabled.contains(&CheckCode::ANN401)
-            {
+            if enforce_annotations {
                 // TODO(charlie): This should be even stricter, in that an overload
                 // implementation should come immediately after the overloaded
                 // interfaces, without any AST nodes in between. Right now, we
@@ -3370,84 +3443,110 @@ impl<'a> Checker<'a> {
             }
 
             // pydocstyle
-            if !pydocstyle::plugins::not_empty(self, &definition) {
-                continue;
-            }
-            if !pydocstyle::plugins::not_missing(self, &definition, &visibility) {
-                continue;
-            }
-            if self.settings.enabled.contains(&CheckCode::D200) {
-                pydocstyle::plugins::one_liner(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D201)
-                || self.settings.enabled.contains(&CheckCode::D202)
-            {
-                pydocstyle::plugins::blank_before_after_function(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D203)
-                || self.settings.enabled.contains(&CheckCode::D204)
-                || self.settings.enabled.contains(&CheckCode::D211)
-            {
-                pydocstyle::plugins::blank_before_after_class(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D205) {
-                pydocstyle::plugins::blank_after_summary(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D206)
-                || self.settings.enabled.contains(&CheckCode::D207)
-                || self.settings.enabled.contains(&CheckCode::D208)
-            {
-                pydocstyle::plugins::indent(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D209) {
-                pydocstyle::plugins::newline_after_last_paragraph(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D210) {
-                pydocstyle::plugins::no_surrounding_whitespace(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D212)
-                || self.settings.enabled.contains(&CheckCode::D213)
-            {
-                pydocstyle::plugins::multi_line_summary_start(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D300) {
-                pydocstyle::plugins::triple_quotes(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D400) {
-                pydocstyle::plugins::ends_with_period(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D402) {
-                pydocstyle::plugins::no_signature(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D403) {
-                pydocstyle::plugins::capitalized(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D404) {
-                pydocstyle::plugins::starts_with_this(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D415) {
-                pydocstyle::plugins::ends_with_punctuation(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D418) {
-                pydocstyle::plugins::if_needed(self, &definition);
-            }
-            if self.settings.enabled.contains(&CheckCode::D212)
-                || self.settings.enabled.contains(&CheckCode::D214)
-                || self.settings.enabled.contains(&CheckCode::D215)
-                || self.settings.enabled.contains(&CheckCode::D405)
-                || self.settings.enabled.contains(&CheckCode::D406)
-                || self.settings.enabled.contains(&CheckCode::D407)
-                || self.settings.enabled.contains(&CheckCode::D408)
-                || self.settings.enabled.contains(&CheckCode::D409)
-                || self.settings.enabled.contains(&CheckCode::D410)
-                || self.settings.enabled.contains(&CheckCode::D411)
-                || self.settings.enabled.contains(&CheckCode::D412)
-                || self.settings.enabled.contains(&CheckCode::D413)
-                || self.settings.enabled.contains(&CheckCode::D414)
-                || self.settings.enabled.contains(&CheckCode::D416)
-                || self.settings.enabled.contains(&CheckCode::D417)
-            {
-                pydocstyle::plugins::sections(self, &definition);
+            if enforce_docstrings {
+                if definition.docstring.is_none() {
+                    pydocstyle::plugins::not_missing(self, &definition, &visibility);
+                    continue;
+                }
+
+                // Extract a `Docstring` from a `Definition`.
+                let expr = definition.docstring.unwrap();
+                let content = self
+                    .locator
+                    .slice_source_code_range(&Range::from_located(expr));
+                let indentation = self.locator.slice_source_code_range(&Range {
+                    location: Location::new(expr.location.row(), 0),
+                    end_location: Location::new(expr.location.row(), expr.location.column()),
+                });
+                let body = pydocstyle::helpers::raw_contents(&content);
+                let docstring = Docstring {
+                    kind: definition.kind,
+                    expr,
+                    contents: &content,
+                    indentation: &indentation,
+                    body,
+                };
+
+                if !pydocstyle::plugins::not_empty(self, &docstring) {
+                    continue;
+                }
+
+                if self.settings.enabled.contains(&CheckCode::D200) {
+                    pydocstyle::plugins::one_liner(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D201)
+                    || self.settings.enabled.contains(&CheckCode::D202)
+                {
+                    pydocstyle::plugins::blank_before_after_function(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D203)
+                    || self.settings.enabled.contains(&CheckCode::D204)
+                    || self.settings.enabled.contains(&CheckCode::D211)
+                {
+                    pydocstyle::plugins::blank_before_after_class(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D205) {
+                    pydocstyle::plugins::blank_after_summary(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D206)
+                    || self.settings.enabled.contains(&CheckCode::D207)
+                    || self.settings.enabled.contains(&CheckCode::D208)
+                {
+                    pydocstyle::plugins::indent(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D209) {
+                    pydocstyle::plugins::newline_after_last_paragraph(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D210) {
+                    pydocstyle::plugins::no_surrounding_whitespace(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D212)
+                    || self.settings.enabled.contains(&CheckCode::D213)
+                {
+                    pydocstyle::plugins::multi_line_summary_start(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D300) {
+                    pydocstyle::plugins::triple_quotes(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D301) {
+                    pydocstyle::plugins::backslashes(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D400) {
+                    pydocstyle::plugins::ends_with_period(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D402) {
+                    pydocstyle::plugins::no_signature(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D403) {
+                    pydocstyle::plugins::capitalized(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D404) {
+                    pydocstyle::plugins::starts_with_this(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D415) {
+                    pydocstyle::plugins::ends_with_punctuation(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D418) {
+                    pydocstyle::plugins::if_needed(self, &docstring);
+                }
+                if self.settings.enabled.contains(&CheckCode::D212)
+                    || self.settings.enabled.contains(&CheckCode::D214)
+                    || self.settings.enabled.contains(&CheckCode::D215)
+                    || self.settings.enabled.contains(&CheckCode::D405)
+                    || self.settings.enabled.contains(&CheckCode::D406)
+                    || self.settings.enabled.contains(&CheckCode::D407)
+                    || self.settings.enabled.contains(&CheckCode::D408)
+                    || self.settings.enabled.contains(&CheckCode::D409)
+                    || self.settings.enabled.contains(&CheckCode::D410)
+                    || self.settings.enabled.contains(&CheckCode::D411)
+                    || self.settings.enabled.contains(&CheckCode::D412)
+                    || self.settings.enabled.contains(&CheckCode::D413)
+                    || self.settings.enabled.contains(&CheckCode::D414)
+                    || self.settings.enabled.contains(&CheckCode::D416)
+                    || self.settings.enabled.contains(&CheckCode::D417)
+                {
+                    pydocstyle::plugins::sections(self, &docstring);
+                }
             }
         }
     }

src/checks.rs

@@ -93,6 +93,7 @@ pub enum CheckCode {
     F823,
     F831,
     F841,
+    F842,
     F901,
     // pylint
     PLC0414,
@@ -243,6 +244,7 @@ pub enum CheckCode {
     D214,
     D215,
     D300,
+    D301,
     D400,
     D402,
     D403,
@@ -627,6 +629,7 @@ pub enum CheckKind {
     TwoStarredExpressions,
     UndefinedExport(String),
     UndefinedLocal(String),
+    UnusedAnnotation(String),
     UndefinedName(String),
     UnusedImport(String, bool),
     UnusedVariable(String),
@@ -796,6 +799,7 @@ pub enum CheckKind {
     SectionUnderlineMatchesSectionLength(String),
     SectionUnderlineNotOverIndented(String),
     SkipDocstring,
+    UsesRPrefixForBackslashedContent,
     UsesTripleQuotes,
     // pep8-naming
     InvalidClassName(String),
@@ -940,6 +944,7 @@ impl CheckCode {
             CheckCode::F823 => CheckKind::UndefinedLocal("...".to_string()),
             CheckCode::F831 => CheckKind::DuplicateArgumentName,
             CheckCode::F841 => CheckKind::UnusedVariable("...".to_string()),
+            CheckCode::F842 => CheckKind::UnusedAnnotation("...".to_string()),
             CheckCode::F901 => CheckKind::RaiseNotImplemented,
             // pylint
             CheckCode::PLC0414 => CheckKind::UselessImportAlias,
@@ -1112,6 +1117,7 @@ impl CheckCode {
             CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
             CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
             CheckCode::D300 => CheckKind::UsesTripleQuotes,
+            CheckCode::D301 => CheckKind::UsesRPrefixForBackslashedContent,
             CheckCode::D400 => CheckKind::EndsInPeriod,
             CheckCode::D402 => CheckKind::NoSignature,
             CheckCode::D403 => CheckKind::FirstLineCapitalized,
@@ -1292,6 +1298,7 @@ impl CheckCode {
             CheckCode::D214 => CheckCategory::Pydocstyle,
             CheckCode::D215 => CheckCategory::Pydocstyle,
             CheckCode::D300 => CheckCategory::Pydocstyle,
+            CheckCode::D301 => CheckCategory::Pydocstyle,
             CheckCode::D400 => CheckCategory::Pydocstyle,
             CheckCode::D402 => CheckCategory::Pydocstyle,
             CheckCode::D403 => CheckCategory::Pydocstyle,
@@ -1368,6 +1375,7 @@ impl CheckCode {
             CheckCode::F823 => CheckCategory::Pyflakes,
             CheckCode::F831 => CheckCategory::Pyflakes,
             CheckCode::F841 => CheckCategory::Pyflakes,
+            CheckCode::F842 => CheckCategory::Pyflakes,
             CheckCode::F901 => CheckCategory::Pyflakes,
             CheckCode::FBT001 => CheckCategory::Flake8BooleanTrap,
             CheckCode::FBT002 => CheckCategory::Flake8BooleanTrap,
@@ -1516,6 +1524,7 @@ impl CheckKind {
             CheckKind::UndefinedName(_) => &CheckCode::F821,
             CheckKind::UnusedImport(..) => &CheckCode::F401,
             CheckKind::UnusedVariable(_) => &CheckCode::F841,
+            CheckKind::UnusedAnnotation(_) => &CheckCode::F842,
             CheckKind::YieldOutsideFunction(_) => &CheckCode::F704,
             // pycodestyle warnings
             CheckKind::NoNewLineAtEndOfFile => &CheckCode::W292,
@@ -1685,6 +1694,7 @@ impl CheckKind {
             CheckKind::SectionUnderlineMatchesSectionLength(_) => &CheckCode::D409,
             CheckKind::SectionUnderlineNotOverIndented(_) => &CheckCode::D215,
             CheckKind::SkipDocstring => &CheckCode::D418,
+            CheckKind::UsesRPrefixForBackslashedContent => &CheckCode::D301,
             CheckKind::UsesTripleQuotes => &CheckCode::D300,
             // pep8-naming
             CheckKind::InvalidClassName(_) => &CheckCode::N801,
@@ -1902,6 +1912,9 @@ impl CheckKind {
             CheckKind::UndefinedName(name) => {
                 format!("Undefined name `{name}`")
             }
+            CheckKind::UnusedAnnotation(name) => {
+                format!("Local variable `{name}` is annotated but never used")
+            }
             CheckKind::UnusedImport(name, ignore_init) => {
                 if *ignore_init {
                     format!(
@@ -1931,8 +1944,8 @@ impl CheckKind {
                 let types = types.join(", ");
                 format!("Merge these isinstance calls: `isinstance({obj}, ({types}))`")
             }
-            CheckKind::MisplacedComparisonConstant(comprison) => {
-                format!("Comparison should be {comprison}")
+            CheckKind::MisplacedComparisonConstant(comparison) => {
+                format!("Comparison should be {comparison}")
             }
             CheckKind::UnnecessaryDirectLambdaCall => "Lambda expression called directly. Execute \
                                                        the expression inline instead."
@@ -2340,6 +2353,9 @@ impl CheckKind {
             CheckKind::FirstLineCapitalized => {
                 "First word of the first line should be properly capitalized".to_string()
             }
+            CheckKind::UsesRPrefixForBackslashedContent => {
+                r#"Use r""" if any backslashes in a docstring"#.to_string()
+            }
             CheckKind::UsesTripleQuotes => r#"Use """triple double quotes""""#.to_string(),
             CheckKind::MultiLineSummaryFirstLine => {
                 "Multi-line docstring summary should start at the first line".to_string()

src/checks_gen.rs

@@ -139,6 +139,7 @@ pub enum CheckCodePrefix {
     D3,
     D30,
     D300,
+    D301,
     D4,
     D40,
     D400,
@@ -253,6 +254,7 @@ pub enum CheckCodePrefix {
     F831,
     F84,
     F841,
+    F842,
     F9,
     F90,
     F901,
@@ -761,6 +763,7 @@ impl CheckCodePrefix {
                 CheckCode::D214,
                 CheckCode::D215,
                 CheckCode::D300,
+                CheckCode::D301,
                 CheckCode::D400,
                 CheckCode::D402,
                 CheckCode::D403,
@@ -863,9 +866,10 @@ impl CheckCodePrefix {
             CheckCodePrefix::D213 => vec![CheckCode::D213],
             CheckCodePrefix::D214 => vec![CheckCode::D214],
             CheckCodePrefix::D215 => vec![CheckCode::D215],
-            CheckCodePrefix::D3 => vec![CheckCode::D300],
-            CheckCodePrefix::D30 => vec![CheckCode::D300],
+            CheckCodePrefix::D3 => vec![CheckCode::D300, CheckCode::D301],
+            CheckCodePrefix::D30 => vec![CheckCode::D300, CheckCode::D301],
             CheckCodePrefix::D300 => vec![CheckCode::D300],
+            CheckCodePrefix::D301 => vec![CheckCode::D301],
             CheckCodePrefix::D4 => vec![
                 CheckCode::D400,
                 CheckCode::D402,
@@ -1034,6 +1038,7 @@ impl CheckCodePrefix {
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
                 CheckCode::F901,
             ],
             CheckCodePrefix::F4 => vec![
@@ -1167,6 +1172,7 @@ impl CheckCodePrefix {
                 CheckCode::F823,
                 CheckCode::F831,
                 CheckCode::F841,
+                CheckCode::F842,
             ],
             CheckCodePrefix::F81 => vec![CheckCode::F811],
             CheckCodePrefix::F811 => vec![CheckCode::F811],
@@ -1176,8 +1182,9 @@ impl CheckCodePrefix {
             CheckCodePrefix::F823 => vec![CheckCode::F823],
             CheckCodePrefix::F83 => vec![CheckCode::F831],
             CheckCodePrefix::F831 => vec![CheckCode::F831],
-            CheckCodePrefix::F84 => vec![CheckCode::F841],
+            CheckCodePrefix::F84 => vec![CheckCode::F841, CheckCode::F842],
             CheckCodePrefix::F841 => vec![CheckCode::F841],
+            CheckCodePrefix::F842 => vec![CheckCode::F842],
             CheckCodePrefix::F9 => vec![CheckCode::F901],
             CheckCodePrefix::F90 => vec![CheckCode::F901],
             CheckCodePrefix::F901 => vec![CheckCode::F901],
@@ -1935,6 +1942,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::D3 => SuffixLength::One,
             CheckCodePrefix::D30 => SuffixLength::Two,
             CheckCodePrefix::D300 => SuffixLength::Three,
+            CheckCodePrefix::D301 => SuffixLength::Three,
             CheckCodePrefix::D4 => SuffixLength::One,
             CheckCodePrefix::D40 => SuffixLength::Two,
             CheckCodePrefix::D400 => SuffixLength::Three,
@@ -2049,6 +2057,7 @@ impl CheckCodePrefix {
             CheckCodePrefix::F831 => SuffixLength::Three,
             CheckCodePrefix::F84 => SuffixLength::Two,
             CheckCodePrefix::F841 => SuffixLength::Three,
+            CheckCodePrefix::F842 => SuffixLength::Three,
             CheckCodePrefix::F9 => SuffixLength::One,
             CheckCodePrefix::F90 => SuffixLength::Two,
             CheckCodePrefix::F901 => SuffixLength::Three,

src/docstrings/constants.rs

@@ -1,5 +1,9 @@
 pub const TRIPLE_QUOTE_PREFIXES: &[&str] = &[
-    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "\"\"\"", "'''",
+    "ur\"\"\"", "ur'''", "u\"\"\"", "u'''", "r\"\"\"", "r'''", "UR\"\"\"", "UR'''", "Ur\"\"\"",
+    "Ur'''", "U\"\"\"", "U'''", "uR\"\"\"", "uR'''", "R\"\"\"", "R'''", "\"\"\"", "'''",
 ];
 
-pub const SINGLE_QUOTE_PREFIXES: &[&str] = &["ur\"", "ur'", "u\"", "u'", "r\"", "r'", "\"", "'"];
+pub const SINGLE_QUOTE_PREFIXES: &[&str] = &[
+    "ur\"", "ur'", "u\"", "u'", "r\"", "r'", "ur\"", "ur'", "u\"", "u'", "r\"", "r'", "UR\"",
+    "UR'", "Ur\"", "Ur'", "U\"", "U'", "uR\"", "uR'", "R\"", "R'", "\"", "'",
+];

src/docstrings/definition.rs

@@ -1,6 +1,8 @@
+use std::borrow::Cow;
+
 use rustpython_ast::{Expr, Stmt};
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum DefinitionKind<'a> {
     Module,
     Package,
@@ -17,6 +19,15 @@ pub struct Definition<'a> {
     pub docstring: Option<&'a Expr>,
 }
 
+#[derive(Debug)]
+pub struct Docstring<'a> {
+    pub kind: DefinitionKind<'a>,
+    pub expr: &'a Expr,
+    pub contents: &'a Cow<'a, str>,
+    pub body: &'a str,
+    pub indentation: &'a Cow<'a, str>,
+}
+
 pub enum Documentable {
     Class,
     Function,

src/docstrings/sections.rs

@@ -3,7 +3,7 @@ use crate::docstrings::styles::SectionStyle;
 
 #[derive(Debug)]
 pub(crate) struct SectionContext<'a> {
-    pub(crate) section_name: String,
+    pub(crate) section_name: &'a str,
     pub(crate) previous_line: &'a str,
     pub(crate) line: &'a str,
     pub(crate) following_lines: &'a [&'a str],
@@ -22,7 +22,7 @@ fn is_docstring_section(context: &SectionContext) -> bool {
     let section_name_suffix = context
         .line
         .trim()
-        .strip_prefix(&context.section_name)
+        .strip_prefix(context.section_name)
         .unwrap()
         .trim();
     let this_looks_like_a_section_name =

src/flake8_return/visitor.rs

@@ -18,6 +18,8 @@ pub struct Stack<'a> {
 #[derive(Default)]
 pub struct ReturnVisitor<'a> {
     pub stack: Stack<'a>,
+    // If we're in an f-string, the location of the defining expression.
+    in_f_string: Option<Location>,
 }
 
 impl<'a> ReturnVisitor<'a> {
@@ -34,7 +36,7 @@ impl<'a> ReturnVisitor<'a> {
                     .assigns
                     .entry(id)
                     .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
                 return;
             }
             _ => {}
@@ -70,7 +72,7 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                         .refs
                         .entry(id)
                         .or_insert_with(Vec::new)
-                        .push(value.location);
+                        .push(self.in_f_string.unwrap_or(value.location));
                 }
 
                 visitor::walk_expr(self, value);
@@ -111,7 +113,13 @@ impl<'a> Visitor<'a> for ReturnVisitor<'a> {
                     .refs
                     .entry(id)
                     .or_insert_with(Vec::new)
-                    .push(expr.location);
+                    .push(self.in_f_string.unwrap_or(expr.location));
+            }
+            ExprKind::JoinedStr { .. } => {
+                let prev_in_f_string = self.in_f_string;
+                self.in_f_string = Some(expr.location);
+                visitor::walk_expr(self, expr);
+                self.in_f_string = prev_in_f_string;
             }
             _ => visitor::walk_expr(self, expr),
         }

src/isort/plugins.rs

@@ -19,14 +19,12 @@ fn extract_range(body: &[&Stmt]) -> Range {
     }
 }
 
-fn extract_indentation(body: &[&Stmt], locator: &SourceCodeLocator) -> String {
+fn extract_indentation_range(body: &[&Stmt]) -> Range {
     let location = body.first().unwrap().location;
-    let range = Range {
+    Range {
         location: Location::new(location.row(), 0),
         end_location: location,
-    };
-    let existing = locator.slice_source_code_range(&range);
-    leading_space(&existing)
+    }
 }
 
 /// I001
@@ -36,8 +34,10 @@ pub fn check_imports(
     settings: &Settings,
     autofix: bool,
 ) -> Option<Check> {
+    let indentation = locator.slice_source_code_range(&extract_indentation_range(&block.imports));
+    let indentation = leading_space(&indentation);
+
     let range = extract_range(&block.imports);
-    let indentation = extract_indentation(&block.imports, locator);
 
     // Extract comments. Take care to grab any inline comments from the last line.
     let comments = comments::collect_comments(
@@ -77,7 +77,7 @@ pub fn check_imports(
             if has_leading_content {
                 content.push('\n');
             }
-            content.push_str(&indent(&expected, &indentation));
+            content.push_str(&indent(&expected, indentation));
             check.amend(Fix::replacement(
                 content,
                 // Preserve leading prefix (but put the imports on a new line).
@@ -104,7 +104,7 @@ pub fn check_imports(
             let mut check = Check::new(CheckKind::UnsortedImports, range);
             if autofix && settings.fixable.contains(check.kind.code()) {
                 check.amend(Fix::replacement(
-                    indent(&expected, &indentation),
+                    indent(&expected, indentation),
                     range.location,
                     range.end_location,
                 ));

src/isort/settings.rs

@@ -32,11 +32,16 @@ pub struct Options {
                 test_id as test_id
             )
             ```
+
+            Note that this setting is only effective when combined with `combine-as-imports = true`.
+            When `combine-as-imports` isn't enabled, every aliased `import from` will be given its
+            own line, in which case, wrapping is not necessary.
         "#,
         default = r#"false"#,
         value_type = "bool",
         example = r#"
             force-wrap-aliases = true
+            combine-as-imports = true
         "#
     )]
     pub force_wrap_aliases: Option<bool>,

src/pycodestyle/plugins.rs

@@ -298,11 +298,11 @@ pub fn do_not_assign_lambda(checker: &mut Checker, target: &Expr, value: &Expr,
                 {
                     match function(id, args, body) {
                         Ok(content) => {
-                            let indentation =
-                                &leading_space(&checker.locator.slice_source_code_range(&Range {
-                                    location: Location::new(stmt.location.row(), 0),
-                                    end_location: Location::new(stmt.location.row() + 1, 0),
-                                }));
+                            let first_line = checker.locator.slice_source_code_range(&Range {
+                                location: Location::new(stmt.location.row(), 0),
+                                end_location: Location::new(stmt.location.row() + 1, 0),
+                            });
+                            let indentation = &leading_space(&first_line);
                             let mut indented = String::new();
                             for (idx, line) in content.lines().enumerate() {
                                 if idx == 0 {

src/pydocstyle/helpers.rs

@@ -1,17 +1,23 @@
-use rustpython_ast::Expr;
-
-use crate::ast::types::Range;
 use crate::docstrings::constants;
-use crate::SourceCodeLocator;
+
+/// Strip the leading and trailing quotes from a docstring.
+pub fn raw_contents(contents: &str) -> &str {
+    for pattern in constants::TRIPLE_QUOTE_PREFIXES {
+        if contents.starts_with(pattern) {
+            return &contents[pattern.len()..contents.len() - 3];
+        }
+    }
+    for pattern in constants::SINGLE_QUOTE_PREFIXES {
+        if contents.starts_with(pattern) {
+            return &contents[pattern.len()..contents.len() - 1];
+        }
+    }
+    unreachable!("Expected docstring to start with a valid triple- or single-quote prefix")
+}
 
 /// Return the leading quote string for a docstring (e.g., `"""`).
-pub fn leading_quote<'a>(docstring: &Expr, locator: &'a SourceCodeLocator) -> Option<&'a str> {
-    if let Some(first_line) = locator
-        .slice_source_code_range(&Range::from_located(docstring))
-        .lines()
-        .next()
-        .map(str::to_lowercase)
-    {
+pub fn leading_quote(content: &str) -> Option<&str> {
+    if let Some(first_line) = content.lines().next() {
         for pattern in constants::TRIPLE_QUOTE_PREFIXES
             .iter()
             .chain(constants::SINGLE_QUOTE_PREFIXES)

src/pydocstyle/mod.rs

@@ -1,4 +1,4 @@
-mod helpers;
+pub mod helpers;
 pub mod plugins;
 
 #[cfg(test)]
@@ -37,6 +37,7 @@ mod tests {
     #[test_case(CheckCode::D214, Path::new("sections.py"); "D214")]
     #[test_case(CheckCode::D215, Path::new("sections.py"); "D215")]
     #[test_case(CheckCode::D300, Path::new("D.py"); "D300")]
+    #[test_case(CheckCode::D301, Path::new("D.py"); "D301")]
     #[test_case(CheckCode::D400, Path::new("D.py"); "D400_0")]
     #[test_case(CheckCode::D400, Path::new("D400.py"); "D400_1")]
     #[test_case(CheckCode::D402, Path::new("D.py"); "D402")]

src/pydocstyle/snapshots/ruff__pydocstyle__tests__D301_D.py.snap

@@ -0,0 +1,29 @@
+---
+source: src/pydocstyle/mod.rs
+expression: checks
+---
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 328
+    column: 4
+  end_location:
+    row: 328
+    column: 16
+  fix: ~
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 333
+    column: 4
+  end_location:
+    row: 333
+    column: 20
+  fix: ~
+- kind: UsesRPrefixForBackslashedContent
+  location:
+    row: 338
+    column: 4
+  end_location:
+    row: 338
+    column: 21
+  fix: ~
+

src/pyflakes/checks.rs

@@ -388,7 +388,7 @@ pub fn undefined_local(name: &str, scopes: &[&Scope], bindings: &[Binding]) -> O
 }
 
 /// F841
-pub fn unused_variables(
+pub fn unused_variable(
     scope: &Scope,
     bindings: &[Binding],
     dummy_variable_rgx: &Regex,
@@ -421,6 +421,31 @@ pub fn unused_variables(
     checks
 }
 
+/// F842
+pub fn unused_annotation(
+    scope: &Scope,
+    bindings: &[Binding],
+    dummy_variable_rgx: &Regex,
+) -> Vec<Check> {
+    let mut checks: Vec<Check> = vec![];
+    for (name, binding) in scope
+        .values
+        .iter()
+        .map(|(name, index)| (name, &bindings[*index]))
+    {
+        if binding.used.is_none()
+            && matches!(binding.kind, BindingKind::Annotation)
+            && !dummy_variable_rgx.is_match(name)
+        {
+            checks.push(Check::new(
+                CheckKind::UnusedAnnotation((*name).to_string()),
+                binding.range,
+            ));
+        }
+    }
+    checks
+}
+
 /// F707
 pub fn default_except_not_last(handlers: &[Excepthandler]) -> Option<Check> {
     for (idx, handler) in handlers.iter().enumerate() {

src/pyflakes/foo.rs

@@ -0,0 +1 @@
+

src/pyflakes/snapshots/ruff__pyflakes__tests__F842_F842.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/pyflakes/mod.rs
+expression: checks
+---
+- kind:
+    UnusedAnnotation: name
+  location:
+    row: 2
+    column: 4
+  end_location:
+    row: 2
+    column: 8
+  fix: ~
+- kind:
+    UnusedAnnotation: age
+  location:
+    row: 3
+    column: 4
+  end_location:
+    row: 3
+    column: 7
+  fix: ~
+