Bump version to 0.0.73

Cargo.lock

@@ -1966,7 +1966,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.72"
+version = "0.0.73"
 dependencies = [
  "anyhow",
  "assert_cmd",
@@ -1998,6 +1998,7 @@ dependencies = [
  "serde_json",
  "strum",
  "strum_macros",
+ "test-case",
  "titlecase",
  "toml",
  "update-informer",
@@ -2412,6 +2413,28 @@ version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "507e9898683b6c43a9aa55b64259b721b52ba226e0f3779137e50ad114a4c90b"
 
+[[package]]
+name = "test-case"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21d6cf5a7dffb3f9dceec8e6b8ca528d9bd71d36c9f074defb548ce161f598c0"
+dependencies = [
+ "test-case-macros",
+]
+
+[[package]]
+name = "test-case-macros"
+version = "2.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e45b7bf6e19353ddd832745c8fcf77a17a93171df7151187f26623f2b75b5b26"
+dependencies = [
+ "cfg-if 1.0.0",
+ "proc-macro-error",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.37"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ruff"
-version = "0.0.72"
+version = "0.0.73"
 edition = "2021"
 
 [lib]
@@ -23,26 +23,27 @@ itertools = { version = "0.10.5" }
 libcst = { git = "https://github.com/charliermarsh/LibCST", rev = "32a044c127668df44582f85699358e67803b0d73" }
 log = { version = "0.4.17" }
 notify = { version = "4.0.17" }
+num-bigint = { version = "0.4.3" }
 once_cell = { version = "1.13.1" }
 path-absolutize = { version = "3.0.13", features = ["once_cell_cache"] }
 rayon = { version = "1.5.3" }
 regex = { version = "1.6.0" }
 rustpython-ast = { features = ["unparse"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
-rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
 rustpython-common = { git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
+rustpython-parser = { features = ["lalrpop"], git = "https://github.com/charliermarsh/RustPython.git", rev = "778ae2aeb521d0438d2a91bd11238bb5c2bf9d4f" }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
+strum = { version = "0.24.1", features = ["strum_macros"] }
+strum_macros = { version = "0.24.3" }
+titlecase = { version = "2.2.1" }
 toml = { version = "0.5.9" }
 update-informer = { version = "0.5.0", default_features = false, features = ["pypi"], optional = true }
 walkdir = { version = "2.3.2" }
-strum = { version = "0.24.1", features = ["strum_macros"] }
-strum_macros = "0.24.3"
-num-bigint = "0.4.3"
-titlecase = "2.2.1"
 
 [dev-dependencies]
-assert_cmd = "2.0.4"
+assert_cmd = { version = "2.0.4" }
 insta = { version = "1.19.1", features = ["yaml"] }
+test-case = { version = "2.2.2" }
 
 [features]
 default = ["update-informer"]

README.md

@@ -57,7 +57,7 @@ ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.72
+    rev: v0.0.73
     hooks:
       - id: lint
 ```
@@ -94,6 +94,8 @@ Arguments:
   <FILES>...
 
 Options:
+      --config <CONFIG>
+          Path to the `pyproject.toml` file to use for configuration
   -v, --verbose
           Enable verbose logging
   -q, --quiet
@@ -132,6 +134,8 @@ Options:
           Regular expression matching the name of dummy variables
       --target-version <TARGET_VERSION>
           The minimum Python version that should be supported
+      --stdin-filename <STDIN_FILENAME>
+          The name of the file when passing it through stdin
   -h, --help
           Print help information
   -V, --version
@@ -215,7 +219,7 @@ ruff also implements some of the most popular Flake8 plugins natively, including
 - [`flake8-builtins`](https://pypi.org/project/flake8-builtins/)
 - [`flake8-super`](https://pypi.org/project/flake8-super/)
 - [`flake8-print`](https://pypi.org/project/flake8-print/)
-- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/) (12/16)
+- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/) (15/16)
 - [`flake8-bugbear`](https://pypi.org/project/flake8-bugbear/) (3/32)
 - [`flake8-docstrings`](https://pypi.org/project/flake8-docstrings/) (37/48)
 - [`pyupgrade`](https://pypi.org/project/pyupgrade/) (8/34)
@@ -293,8 +297,11 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | C408 | UnnecessaryCollectionCall | Unnecessary <dict/list/tuple> call - rewrite as a literal |  |  |
 | C409 | UnnecessaryLiteralWithinTupleCall | Unnecessary <list/tuple> literal passed to tuple() - remove the outer call to tuple() |  |  |
 | C410 | UnnecessaryLiteralWithinListCall | Unnecessary <list/tuple> literal passed to list() - rewrite as a list literal |  |  |
+| C411 | UnnecessaryListCall | Unnecessary list call - remove the outer call to list() |  |  |
+| C413 | UnnecessaryCallAroundSorted | Unnecessary <list/reversed> call around sorted() |  |  |
 | C414 | UnnecessaryDoubleCastOrProcess | Unnecessary <list/reversed/set/sorted/tuple> call within <list/set/sorted/tuple>(). |  |  |
 | C415 | UnnecessarySubscriptReversal | Unnecessary subscript reversal of iterable within <reversed/set/sorted>() |  |  |
+| C416 | UnnecessaryComprehension |  Unnecessary <list/set> comprehension - rewrite using <list/set>() |  |  |
 | T201 | PrintFound | `print` found |  | 🛠 |
 | T203 | PPrintFound | `pprint` found |  | 🛠 |
 | U001 | UselessMetaclassType | `__metaclass__ = type` is implied |  | 🛠 |
@@ -314,34 +321,37 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | D106 | PublicNestedClass | Missing docstring in public nested class |  |  |
 | D107 | PublicInit | Missing docstring in __init__ |  |  |
 | D200 | FitsOnOneLine | One-line docstring should fit on one line |  |  |
+| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) |  |  |
+| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) |  |  |
+| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring |  |  |
+| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring |  |  |
 | D205 | NoBlankLineAfterSummary | 1 blank line required between summary line and description |  |  |
 | D209 | NewLineAfterLastParagraph | Multi-line docstring closing quotes should be on a separate line |  |  |
 | D210 | NoSurroundingWhitespace | No whitespaces allowed surrounding docstring text |  |  |
+| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring |  |  |
 | D212 | MultiLineSummaryFirstLine | Multi-line docstring summary should start at the first line |  |  |
 | D213 | MultiLineSummarySecondLine | Multi-line docstring summary should start at the second line |  |  |
+| D214 | SectionNotOverIndented | Section is over-indented ("Returns") |  |  |
+| D215 | SectionUnderlineNotOverIndented | Section underline is over-indented ("Returns") |  |  |
 | D300 | UsesTripleQuotes | Use """triple double quotes""" |  |  |
 | 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 |  |  |
 | D404 | NoThisPrefix | First word of the docstring should not be `This` |  |  |
-| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |  |
-| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |  |
-| D419 | NonEmpty | Docstring is empty |  |  |
-| D201 | NoBlankLineBeforeFunction | No blank lines allowed before function docstring (found 1) |  |  |
-| D202 | NoBlankLineAfterFunction | No blank lines allowed after function docstring (found 1) |  |  |
-| D211 | NoBlankLineBeforeClass | No blank lines allowed before class docstring |  |  |
-| D203 | OneBlankLineBeforeClass | 1 blank line required before class docstring |  |  |
-| D204 | OneBlankLineAfterClass | 1 blank line required after class docstring |  |  |
 | D405 | CapitalizeSectionName | Section name should be properly capitalized ("returns") |  |  |
-| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") |  |  |
-| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") |  |  |
-| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |  |
 | D406 | NewLineAfterSectionName | Section name should end with a newline ("Returns") |  |  |
 | D407 | DashedUnderlineAfterSection | Missing dashed underline after section ("Returns") |  |  |
 | D408 | SectionUnderlineAfterName | Section underline should be in the line following the section's name ("Returns") |  |  |
 | D409 | SectionUnderlineMatchesSectionLength | Section underline should match the length of its name ("Returns") |  |  |
+| D410 | BlankLineAfterSection | Missing blank line after section ("Returns") |  |  |
+| D411 | BlankLineBeforeSection | Missing blank line before section ("Returns") |  |  |
 | D412 | NoBlankLinesBetweenHeaderAndContent | No blank lines allowed between a section header and its content ("Returns") |  |  |
+| D413 | BlankLineAfterLastSection | Missing blank line after last section ("Returns") |  |  |
 | D414 | NonEmptySection | Section has no content ("Returns") |  |  |
+| D415 | EndsInPunctuation | First line should end with a period, question mark, or exclamation point |  |  |
+| D417 | DocumentAllArguments | Missing argument descriptions in the docstring: `x`, `y` |  |  |
+| D418 | SkipDocstring | Function decorated with @overload shouldn't contain a docstring |  |  |
+| D419 | NonEmpty | Docstring is empty |  |  |
 | M001 | UnusedNOQA | Unused `noqa` directive |  | 🛠 |
 
 ## Integrations

resources/test/fixtures/C411.py

@@ -0,0 +1,2 @@
+x = [1, 2, 3]
+list([i for i in x])

resources/test/fixtures/C413.py

@@ -0,0 +1,4 @@
+x = [2, 3, 1]
+list(sorted(x))
+reversed(sorted(x))
+reversed(sorted(x, reverse=True))

resources/test/fixtures/C416.py

@@ -0,0 +1,6 @@
+x = [1, 2, 3]
+[i for i in x]
+{i for i in x}
+
+[i for i in x if i > 1]
+[i for i in x for j in x]

resources/test/fixtures/canonical_numpy_examples.py

@@ -0,0 +1,163 @@
+"""This is the docstring for the example.py module.  Modules names should
+have short, all-lowercase names.  The module name may have underscores if
+this improves readability.
+
+Every module should have a docstring at the very top of the file.  The
+module's docstring may extend over multiple lines.  If your docstring does
+extend over multiple lines, the closing three quotation marks must be on
+a line by itself, preferably preceded by a blank line.
+
+"""
+
+# Example source file from the official "numpydoc docstring guide"
+# documentation (with the modification of commenting out all the original
+# ``import`` lines, plus adding this note and ``Expectation`` code):
+#     * As HTML: https://numpydoc.readthedocs.io/en/latest/example.html
+#     * Source Python:
+#         https://github.com/numpy/numpydoc/blob/master/doc/example.py
+
+# from __future__ import division, absolute_import, print_function
+#
+# import os  # standard library imports first
+#
+# Do NOT import using *, e.g. from numpy import *
+#
+# Import the module using
+#
+#   import numpy
+#
+# instead or import individual functions as needed, e.g
+#
+#  from numpy import array, zeros
+#
+# If you prefer the use of abbreviated module names, we suggest the
+# convention used by NumPy itself::
+#
+# import numpy as np
+# import matplotlib as mpl
+# import matplotlib.pyplot as plt
+#
+# These abbreviated names are not to be used in docstrings; users must
+# be able to paste and execute docstrings after importing only the
+# numpy module itself, unabbreviated.
+
+import os
+from .expected import Expectation
+
+expectation = Expectation()
+expect = expectation.expect
+
+# module docstring expected violations:
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D205: 1 blank line required between summary line and description "
+    "(found 0)"))
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D213: Multi-line docstring summary should start at the second line"))
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D400: First line should end with a period (not 'd')"))
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D404: First word of the docstring should not be `This`"))
+expectation.expected.add((
+    os.path.normcase(__file__),
+    "D415: First line should end with a period, question mark, or exclamation "
+    "point (not 'd')"))
+
+
+@expect("D213: Multi-line docstring summary should start at the second line",
+        arg_count=3)
+@expect("D401: First line should be in imperative mood; try rephrasing "
+        "(found 'A')", arg_count=3)
+@expect("D413: Missing blank line after last section ('Examples')",
+        arg_count=3)
+def foo(var1, var2, long_var_name='hi'):
+    r"""A one-line summary that does not use variable names.
+
+    Several sentences providing an extended description. Refer to
+    variables using back-ticks, e.g. `var`.
+
+    Parameters
+    ----------
+    var1 : array_like
+        Array_like means all those objects -- lists, nested lists, etc. --
+        that can be converted to an array.  We can also refer to
+        variables like `var1`.
+    var2 : int
+        The type above can either refer to an actual Python type
+        (e.g. ``int``), or describe the type of the variable in more
+        detail, e.g. ``(N,) ndarray`` or ``array_like``.
+    long_var_name : {'hi', 'ho'}, optional
+        Choices in brackets, default first when optional.
+
+    Returns
+    -------
+    type
+        Explanation of anonymous return value of type ``type``.
+    describe : type
+        Explanation of return value named `describe`.
+    out : type
+        Explanation of `out`.
+    type_without_description
+
+    Other Parameters
+    ----------------
+    only_seldom_used_keywords : type
+        Explanation
+    common_parameters_listed_above : type
+        Explanation
+
+    Raises
+    ------
+    BadException
+        Because you shouldn't have done that.
+
+    See Also
+    --------
+    numpy.array : Relationship (optional).
+    numpy.ndarray : Relationship (optional), which could be fairly long, in
+                    which case the line wraps here.
+    numpy.dot, numpy.linalg.norm, numpy.eye
+
+    Notes
+    -----
+    Notes about the implementation algorithm (if needed).
+
+    This can have multiple paragraphs.
+
+    You may include some math:
+
+    .. math:: X(e^{j\omega } ) = x(n)e^{ - j\omega n}
+
+    And even use a Greek symbol like :math:`\omega` inline.
+
+    References
+    ----------
+    Cite the relevant literature, e.g. [1]_.  You may also cite these
+    references in the notes section above.
+
+    .. [1] O. McNoleg, "The integration of GIS, remote sensing,
+       expert systems and adaptive co-kriging for environmental habitat
+       modelling of the Highland Haggis using object-oriented, fuzzy-logic
+       and neural-network techniques," Computers & Geosciences, vol. 22,
+       pp. 585-588, 1996.
+
+    Examples
+    --------
+    These are written in doctest format, and should illustrate how to
+    use the function.
+
+    >>> a = [1, 2, 3]
+    >>> print([x + 3 for x in a])
+    [4, 5, 6]
+    >>> print("a\nb")
+    a
+    b
+    """
+    # After closing class docstring, there should be one blank line to
+    # separate following codes (according to PEP257).
+    # But for function, method and module, there should be no blank lines
+    # after closing the docstring.
+    pass

src/ast/checkers.rs

@@ -4,8 +4,8 @@ use itertools::izip;
 use num_bigint::BigInt;
 use regex::Regex;
 use rustpython_parser::ast::{
-    Arg, ArgData, Arguments, Cmpop, Constant, Excepthandler, ExcepthandlerKind, Expr, ExprKind,
-    KeywordData, Located, Stmt, StmtKind, Unaryop,
+    Arg, ArgData, Arguments, Cmpop, Comprehension, Constant, Excepthandler, ExcepthandlerKind,
+    Expr, ExprKind, KeywordData, Located, Stmt, StmtKind, Unaryop,
 };
 use serde::{Deserialize, Serialize};
 
@@ -1004,6 +1004,42 @@ pub fn unnecessary_literal_within_list_call(
     None
 }
 
+pub fn unnecessary_list_call(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+    if let ExprKind::Name { id, .. } = &func.node {
+        if id == "list" {
+            if let Some(arg) = args.first() {
+                if let ExprKind::ListComp { .. } = &arg.node {
+                    return Some(Check::new(
+                        CheckKind::UnnecessaryListCall,
+                        Range::from_located(expr),
+                    ));
+                }
+            }
+        }
+    }
+    None
+}
+
+pub fn unnecessary_call_around_sorted(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<Check> {
+    if let ExprKind::Name { id: outer, .. } = &func.node {
+        if outer == "list" || outer == "reversed" {
+            if let Some(arg) = args.first() {
+                if let ExprKind::Call { func, .. } = &arg.node {
+                    if let ExprKind::Name { id: inner, .. } = &func.node {
+                        if inner == "sorted" {
+                            return Some(Check::new(
+                                CheckKind::UnnecessaryCallAroundSorted(outer.to_string()),
+                                Range::from_located(expr),
+                            ));
+                        }
+                    }
+                }
+            }
+        }
+    }
+    None
+}
+
 pub fn unnecessary_double_cast_or_process(
     expr: &Expr,
     func: &Expr,
@@ -1104,6 +1140,41 @@ pub fn unnecessary_subscript_reversal(expr: &Expr, func: &Expr, args: &[Expr]) -
     None
 }
 
+pub fn unnecessary_comprehension(
+    expr: &Expr,
+    elt: &Located<ExprKind>,
+    generators: &Vec<Comprehension>,
+) -> Option<Check> {
+    if generators.len() == 1 {
+        let generator = &generators[0];
+        if generator.ifs.is_empty() && generator.is_async == 0 {
+            if let ExprKind::Name { id: elt_id, .. } = &elt.node {
+                if let ExprKind::Name { id: target_id, .. } = &generator.target.node {
+                    if elt_id == target_id {
+                        match &expr.node {
+                            ExprKind::ListComp { .. } => {
+                                return Some(Check::new(
+                                    CheckKind::UnnecessaryComprehension("list".to_string()),
+                                    Range::from_located(expr),
+                                ))
+                            }
+                            ExprKind::SetComp { .. } => {
+                                return Some(Check::new(
+                                    CheckKind::UnnecessaryComprehension("set".to_string()),
+                                    Range::from_located(expr),
+                                ))
+                            }
+                            _ => {}
+                        };
+                    }
+                }
+            }
+        }
+    }
+
+    None
+}
+
 // flake8-super
 /// Check that `super()` has no args
 pub fn super_args(

src/check_ast.rs

@@ -837,6 +837,19 @@ where
                     };
                 }
 
+                if self.settings.enabled.contains(&CheckCode::C411) {
+                    if let Some(check) = checkers::unnecessary_list_call(expr, func, args) {
+                        self.checks.push(check);
+                    };
+                }
+
+                if self.settings.enabled.contains(&CheckCode::C413) {
+                    if let Some(check) = checkers::unnecessary_call_around_sorted(expr, func, args)
+                    {
+                        self.checks.push(check);
+                    };
+                }
+
                 if self.settings.enabled.contains(&CheckCode::C414) {
                     if let Some(check) =
                         checkers::unnecessary_double_cast_or_process(expr, func, args)
@@ -1021,10 +1034,20 @@ where
                     self.visit_expr(expr);
                 }
             }
-            ExprKind::GeneratorExp { .. }
-            | ExprKind::ListComp { .. }
-            | ExprKind::DictComp { .. }
-            | ExprKind::SetComp { .. } => self.push_scope(Scope::new(ScopeKind::Generator)),
+
+            ExprKind::ListComp { elt, generators } | ExprKind::SetComp { elt, generators } => {
+                if self.settings.enabled.contains(&CheckCode::C416) {
+                    if let Some(check) = checkers::unnecessary_comprehension(expr, elt, generators)
+                    {
+                        self.checks.push(check);
+                    };
+                }
+                self.push_scope(Scope::new(ScopeKind::Generator))
+            }
+
+            ExprKind::GeneratorExp { .. } | ExprKind::DictComp { .. } => {
+                self.push_scope(Scope::new(ScopeKind::Generator))
+            }
             _ => {}
         };
 
@@ -1634,7 +1657,6 @@ impl<'a> Checker<'a> {
 
     fn handle_node_delete(&mut self, expr: &Expr) {
         if let ExprKind::Name { id, .. } = &expr.node {
-            // Check if we're on a conditional branch.
             if operations::on_conditional_branch(&self.parent_stack, &self.parents) {
                 return;
             }
@@ -1973,20 +1995,23 @@ impl<'a> Checker<'a> {
             if self.settings.enabled.contains(&CheckCode::D418) {
                 docstring_checks::if_needed(self, &docstring);
             }
-            if self.settings.enabled.contains(&CheckCode::D407)
-                || self.settings.enabled.contains(&CheckCode::D414)
+            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::D407)
-                || self.settings.enabled.contains(&CheckCode::D212)
                 || self.settings.enabled.contains(&CheckCode::D408)
                 || self.settings.enabled.contains(&CheckCode::D409)
-                || self.settings.enabled.contains(&CheckCode::D414)
-                || self.settings.enabled.contains(&CheckCode::D412)
-                || self.settings.enabled.contains(&CheckCode::D414)
-                || self.settings.enabled.contains(&CheckCode::D405)
-                || self.settings.enabled.contains(&CheckCode::D413)
                 || self.settings.enabled.contains(&CheckCode::D410)
                 || self.settings.enabled.contains(&CheckCode::D411)
-                || self.settings.enabled.contains(&CheckCode::D406)
+                || self.settings.enabled.contains(&CheckCode::D412)
+                || self.settings.enabled.contains(&CheckCode::D413)
+                || self.settings.enabled.contains(&CheckCode::D414)
+                || self.settings.enabled.contains(&CheckCode::D414)
+                || self.settings.enabled.contains(&CheckCode::D414)
+                || self.settings.enabled.contains(&CheckCode::D417)
             {
                 docstring_checks::check_sections(self, &docstring);
             }

src/checks.rs

@@ -137,8 +137,11 @@ pub enum CheckCode {
     C408,
     C409,
     C410,
+    C411,
+    C413,
     C414,
     C415,
+    C416,
     // flake8-print
     T201,
     T203,
@@ -171,6 +174,8 @@ pub enum CheckCode {
     D211,
     D212,
     D213,
+    D214,
+    D215,
     D300,
     D400,
     D402,
@@ -187,6 +192,7 @@ pub enum CheckCode {
     D413,
     D414,
     D415,
+    D417,
     D418,
     D419,
     // Meta
@@ -272,8 +278,11 @@ pub enum CheckKind {
     UnnecessaryCollectionCall(String),
     UnnecessaryLiteralWithinTupleCall(String),
     UnnecessaryLiteralWithinListCall(String),
+    UnnecessaryListCall,
+    UnnecessaryCallAroundSorted(String),
     UnnecessaryDoubleCastOrProcess(String, String),
     UnnecessarySubscriptReversal(String),
+    UnnecessaryComprehension(String),
     // flake8-print
     PrintFound,
     PPrintFound,
@@ -292,6 +301,7 @@ pub enum CheckKind {
     BlankLineBeforeSection(String),
     CapitalizeSectionName(String),
     DashedUnderlineAfterSection(String),
+    DocumentAllArguments(Vec<String>),
     EndsInPeriod,
     EndsInPunctuation,
     FirstLineCapitalized,
@@ -320,8 +330,10 @@ pub enum CheckKind {
     PublicModule,
     PublicNestedClass,
     PublicPackage,
+    SectionNotOverIndented(String),
     SectionUnderlineAfterName(String),
     SectionUnderlineMatchesSectionLength(String),
+    SectionUnderlineNotOverIndented(String),
     SkipDocstring,
     UsesTripleQuotes,
     // Meta
@@ -414,6 +426,10 @@ impl CheckCode {
             CheckCode::C410 => {
                 CheckKind::UnnecessaryLiteralWithinListCall("<list/tuple>".to_string())
             }
+            CheckCode::C411 => CheckKind::UnnecessaryListCall,
+            CheckCode::C413 => {
+                CheckKind::UnnecessaryCallAroundSorted("<list/reversed>".to_string())
+            }
             CheckCode::C414 => CheckKind::UnnecessaryDoubleCastOrProcess(
                 "<list/reversed/set/sorted/tuple>".to_string(),
                 "<list/set/sorted/tuple>".to_string(),
@@ -421,6 +437,7 @@ impl CheckCode {
             CheckCode::C415 => {
                 CheckKind::UnnecessarySubscriptReversal("<reversed/set/sorted>".to_string())
             }
+            CheckCode::C416 => CheckKind::UnnecessaryComprehension("<list/set>".to_string()),
             // flake8-print
             CheckCode::T201 => CheckKind::PrintFound,
             CheckCode::T203 => CheckKind::PPrintFound,
@@ -478,6 +495,11 @@ impl CheckCode {
             CheckCode::D415 => CheckKind::EndsInPunctuation,
             CheckCode::D418 => CheckKind::SkipDocstring,
             CheckCode::D419 => CheckKind::NonEmpty,
+            CheckCode::D214 => CheckKind::SectionNotOverIndented("Returns".to_string()),
+            CheckCode::D215 => CheckKind::SectionUnderlineNotOverIndented("Returns".to_string()),
+            CheckCode::D417 => {
+                CheckKind::DocumentAllArguments(vec!["x".to_string(), "y".to_string()])
+            }
             // Meta
             CheckCode::M001 => CheckKind::UnusedNOQA(None),
         }
@@ -552,8 +574,11 @@ impl CheckKind {
             CheckKind::UnnecessaryCollectionCall(_) => &CheckCode::C408,
             CheckKind::UnnecessaryLiteralWithinTupleCall(..) => &CheckCode::C409,
             CheckKind::UnnecessaryLiteralWithinListCall(..) => &CheckCode::C410,
+            CheckKind::UnnecessaryListCall => &CheckCode::C411,
+            CheckKind::UnnecessaryCallAroundSorted(_) => &CheckCode::C413,
             CheckKind::UnnecessaryDoubleCastOrProcess(..) => &CheckCode::C414,
             CheckKind::UnnecessarySubscriptReversal(_) => &CheckCode::C415,
+            CheckKind::UnnecessaryComprehension(..) => &CheckCode::C416,
             // flake8-print
             CheckKind::PrintFound => &CheckCode::T201,
             CheckKind::PPrintFound => &CheckCode::T203,
@@ -572,6 +597,7 @@ impl CheckKind {
             CheckKind::BlankLineBeforeSection(_) => &CheckCode::D411,
             CheckKind::CapitalizeSectionName(_) => &CheckCode::D405,
             CheckKind::DashedUnderlineAfterSection(_) => &CheckCode::D407,
+            CheckKind::DocumentAllArguments(_) => &CheckCode::D417,
             CheckKind::EndsInPeriod => &CheckCode::D400,
             CheckKind::EndsInPunctuation => &CheckCode::D415,
             CheckKind::FirstLineCapitalized => &CheckCode::D403,
@@ -600,8 +626,10 @@ impl CheckKind {
             CheckKind::PublicModule => &CheckCode::D100,
             CheckKind::PublicNestedClass => &CheckCode::D106,
             CheckKind::PublicPackage => &CheckCode::D104,
+            CheckKind::SectionNotOverIndented(_) => &CheckCode::D214,
             CheckKind::SectionUnderlineAfterName(_) => &CheckCode::D408,
             CheckKind::SectionUnderlineMatchesSectionLength(_) => &CheckCode::D409,
+            CheckKind::SectionUnderlineNotOverIndented(_) => &CheckCode::D215,
             CheckKind::SkipDocstring => &CheckCode::D418,
             CheckKind::UsesTripleQuotes => &CheckCode::D300,
             // Meta
@@ -816,12 +844,21 @@ impl CheckKind {
                     )
                 }
             }
+            CheckKind::UnnecessaryListCall => {
+                "Unnecessary list call - remove the outer call to list()".to_string()
+            }
+            CheckKind::UnnecessaryCallAroundSorted(func) => {
+                format!("Unnecessary {func} call around sorted()")
+            }
             CheckKind::UnnecessaryDoubleCastOrProcess(inner, outer) => {
                 format!("Unnecessary {inner} call within {outer}().")
             }
             CheckKind::UnnecessarySubscriptReversal(func) => {
                 format!("Unnecessary subscript reversal of iterable within {func}()")
             }
+            CheckKind::UnnecessaryComprehension(obj_type) => {
+                format!(" Unnecessary {obj_type} comprehension - rewrite using {obj_type}()")
+            }
             // flake8-print
             CheckKind::PrintFound => "`print` found".to_string(),
             CheckKind::PPrintFound => "`pprint` found".to_string(),
@@ -939,6 +976,21 @@ impl CheckKind {
                 )
             }
             CheckKind::NonEmptySection(name) => format!("Section has no content (\"{name}\")"),
+            CheckKind::SectionNotOverIndented(name) => {
+                format!("Section is over-indented (\"{name}\")")
+            }
+            CheckKind::SectionUnderlineNotOverIndented(name) => {
+                format!("Section underline is over-indented (\"{name}\")")
+            }
+            CheckKind::DocumentAllArguments(names) => {
+                if names.len() == 1 {
+                    let name = &names[0];
+                    format!("Missing argument description in the docstring: `{name}`")
+                } else {
+                    let names = names.iter().map(|name| format!("`{name}`")).join(", ");
+                    format!("Missing argument descriptions in the docstring: {names}")
+                }
+            }
             // Meta
             CheckKind::UnusedNOQA(codes) => match codes {
                 None => "Unused `noqa` directive".to_string(),

src/cli.rs

@@ -17,6 +17,9 @@ use crate::RawSettings;
 pub struct Cli {
     #[arg(required = true)]
     pub files: Vec<PathBuf>,
+    /// Path to the `pyproject.toml` file to use for configuration.
+    #[arg(long)]
+    pub config: Option<PathBuf>,
     /// Enable verbose logging.
     #[arg(short, long)]
     pub verbose: bool,

src/docstrings/sections.rs

@@ -1,12 +1,16 @@
+use itertools::Itertools;
 use std::collections::BTreeSet;
 
 use once_cell::sync::Lazy;
+use rustpython_ast::{Arg, Expr, Location, StmtKind};
 use titlecase::titlecase;
 
+use crate::ast::types::Range;
 use crate::check_ast::Checker;
 use crate::checks::{Check, CheckCode, CheckKind};
 use crate::docstrings::docstring_checks::range_for;
-use crate::docstrings::types::Definition;
+use crate::docstrings::types::{Definition, DefinitionKind};
+use crate::visibility::is_static;
 
 static NUMPY_SECTION_NAMES: Lazy<BTreeSet<&'static str>> = Lazy::new(|| {
     BTreeSet::from([
@@ -78,7 +82,21 @@ static NUMPY_SECTION_NAMES_LOWERCASE: Lazy<BTreeSet<&'static str>> = Lazy::new(|
 //     ])
 // });
 
-fn get_leading_words(line: &str) -> String {
+fn indentation<'a>(checker: &'a mut Checker, docstring: &Expr) -> &'a str {
+    let range = range_for(docstring);
+    checker.locator.slice_source_code_range(&Range {
+        location: Location::new(range.location.row(), 1),
+        end_location: Location::new(range.location.row(), range.location.column()),
+    })
+}
+
+fn leading_space(line: &str) -> String {
+    line.chars()
+        .take_while(|char| char.is_whitespace())
+        .collect()
+}
+
+fn leading_words(line: &str) -> String {
     line.trim()
         .chars()
         .take_while(|char| char.is_alphanumeric() || char.is_whitespace())
@@ -86,7 +104,7 @@ fn get_leading_words(line: &str) -> String {
 }
 
 fn suspected_as_section(line: &str) -> bool {
-    NUMPY_SECTION_NAMES_LOWERCASE.contains(&get_leading_words(line).to_lowercase().as_str())
+    NUMPY_SECTION_NAMES_LOWERCASE.contains(&leading_words(line).to_lowercase().as_str())
 }
 
 #[derive(Debug)]
@@ -143,7 +161,7 @@ pub fn section_contexts<'a>(lines: &'a [&'a str]) -> Vec<SectionContext<'a>> {
     let mut contexts = vec![];
     for lineno in suspected_section_indices {
         let context = SectionContext {
-            section_name: get_leading_words(lines[lineno]),
+            section_name: leading_words(lines[lineno]),
             previous_line: lines[lineno - 1],
             line: lines[lineno],
             following_lines: &lines[lineno + 1..],
@@ -196,14 +214,12 @@ fn check_blanks_and_section_underline(
 
     // Nothing but blank lines after the section header.
     if blank_lines_after_header == context.following_lines.len() {
-        // D407
         if checker.settings.enabled.contains(&CheckCode::D407) {
             checker.add_check(Check::new(
                 CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
                 range_for(docstring),
             ));
         }
-        // D414
         if checker.settings.enabled.contains(&CheckCode::D414) {
             checker.add_check(Check::new(
                 CheckKind::NonEmptySection(context.section_name.to_string()),
@@ -219,7 +235,6 @@ fn check_blanks_and_section_underline(
         .all(|char| char.is_whitespace() || char == '-');
 
     if !dash_line_found {
-        // D407
         if checker.settings.enabled.contains(&CheckCode::D407) {
             checker.add_check(Check::new(
                 CheckKind::DashedUnderlineAfterSection(context.section_name.to_string()),
@@ -227,7 +242,6 @@ fn check_blanks_and_section_underline(
             ));
         }
         if blank_lines_after_header > 0 {
-            // D212
             if checker.settings.enabled.contains(&CheckCode::D212) {
                 checker.add_check(Check::new(
                     CheckKind::NoBlankLinesBetweenHeaderAndContent(
@@ -239,7 +253,6 @@ fn check_blanks_and_section_underline(
         }
     } else {
         if blank_lines_after_header > 0 {
-            // D408
             if checker.settings.enabled.contains(&CheckCode::D408) {
                 checker.add_check(Check::new(
                     CheckKind::SectionUnderlineAfterName(context.section_name.to_string()),
@@ -255,7 +268,6 @@ fn check_blanks_and_section_underline(
             .count()
             != context.section_name.len()
         {
-            // D409
             if checker.settings.enabled.contains(&CheckCode::D409) {
                 checker.add_check(Check::new(
                     CheckKind::SectionUnderlineMatchesSectionLength(
@@ -266,16 +278,22 @@ fn check_blanks_and_section_underline(
             }
         }
 
-        // TODO(charlie): Implement D215, which requires indentation and leading space tracking.
+        if checker.settings.enabled.contains(&CheckCode::D215) {
+            if leading_space(non_empty_line).len() > indentation(checker, docstring).len() {
+                checker.add_check(Check::new(
+                    CheckKind::SectionUnderlineNotOverIndented(context.section_name.to_string()),
+                    range_for(docstring),
+                ));
+            }
+        }
+
         let line_after_dashes_index = blank_lines_after_header + 1;
 
         if line_after_dashes_index < context.following_lines.len() {
             let line_after_dashes = context.following_lines[line_after_dashes_index];
-
             if line_after_dashes.trim().is_empty() {
                 let rest_of_lines = &context.following_lines[line_after_dashes_index..];
                 if rest_of_lines.iter().all(|line| line.trim().is_empty()) {
-                    // D414
                     if checker.settings.enabled.contains(&CheckCode::D414) {
                         checker.add_check(Check::new(
                             CheckKind::NonEmptySection(context.section_name.to_string()),
@@ -283,7 +301,6 @@ fn check_blanks_and_section_underline(
                         ));
                     }
                 } else {
-                    // 412
                     if checker.settings.enabled.contains(&CheckCode::D412) {
                         checker.add_check(Check::new(
                             CheckKind::NoBlankLinesBetweenHeaderAndContent(
@@ -295,7 +312,6 @@ fn check_blanks_and_section_underline(
                 }
             }
         } else {
-            // D414
             if checker.settings.enabled.contains(&CheckCode::D414) {
                 checker.add_check(Check::new(
                     CheckKind::NonEmptySection(context.section_name.to_string()),
@@ -307,7 +323,6 @@ fn check_blanks_and_section_underline(
 }
 
 fn check_common_section(checker: &mut Checker, definition: &Definition, context: &SectionContext) {
-    // TODO(charlie): Implement D214, which requires indentation and leading space tracking.
     let docstring = definition
         .docstring
         .expect("Sections are only available for docstrings.");
@@ -323,6 +338,15 @@ fn check_common_section(checker: &mut Checker, definition: &Definition, context:
         }
     }
 
+    if checker.settings.enabled.contains(&CheckCode::D214) {
+        if leading_space(context.line).len() > indentation(checker, docstring).len() {
+            checker.add_check(Check::new(
+                CheckKind::SectionNotOverIndented(context.section_name.to_string()),
+                range_for(docstring),
+            ))
+        }
+    }
+
     if context
         .following_lines
         .last()
@@ -356,12 +380,110 @@ fn check_common_section(checker: &mut Checker, definition: &Definition, context:
     }
 }
 
+fn check_missing_args(
+    checker: &mut Checker,
+    definition: &Definition,
+    docstrings_args: BTreeSet<&str>,
+) {
+    if let DefinitionKind::Function(parent)
+    | DefinitionKind::NestedFunction(parent)
+    | DefinitionKind::Method(parent) = definition.kind
+    {
+        if let StmtKind::FunctionDef {
+            args: arguments, ..
+        }
+        | StmtKind::AsyncFunctionDef {
+            args: arguments, ..
+        } = &parent.node
+        {
+            // Collect all the arguments into a single vector.
+            let mut all_arguments: Vec<&Arg> = arguments
+                .args
+                .iter()
+                .chain(arguments.posonlyargs.iter())
+                .chain(arguments.kwonlyargs.iter())
+                .skip(
+                    // If this is a non-static method, skip `cls` or `self`.
+                    if matches!(definition.kind, DefinitionKind::Method(_)) && !is_static(parent) {
+                        1
+                    } else {
+                        0
+                    },
+                )
+                .collect();
+            if let Some(arg) = &arguments.vararg {
+                all_arguments.push(arg);
+            }
+            if let Some(arg) = &arguments.kwarg {
+                all_arguments.push(arg);
+            }
+
+            // Look for arguments that weren't included in the docstring.
+            let mut missing_args: BTreeSet<&str> = Default::default();
+            for arg in all_arguments {
+                let arg_name = arg.node.arg.as_str();
+                if arg_name.starts_with('_') {
+                    continue;
+                }
+                if docstrings_args.contains(&arg_name) {
+                    continue;
+                }
+                missing_args.insert(arg_name);
+            }
+
+            if !missing_args.is_empty() {
+                let names = missing_args
+                    .into_iter()
+                    .map(String::from)
+                    .sorted()
+                    .collect();
+                checker.add_check(Check::new(
+                    CheckKind::DocumentAllArguments(names),
+                    Range::from_located(parent),
+                ));
+            }
+        }
+    }
+}
+
+fn check_parameters_section(
+    checker: &mut Checker,
+    definition: &Definition,
+    context: &SectionContext,
+) {
+    // Collect the list of arguments documented in the docstring.
+    let mut docstring_args: BTreeSet<&str> = Default::default();
+    let section_level_indent = leading_space(context.line);
+    for i in 1..context.following_lines.len() {
+        let current_line = context.following_lines[i - 1];
+        let current_leading_space = leading_space(current_line);
+        let next_line = context.following_lines[i];
+        if current_leading_space == section_level_indent
+            && (leading_space(next_line).len() > current_leading_space.len())
+            && !next_line.trim().is_empty()
+        {
+            let parameters = if let Some(semi_index) = current_line.find(':') {
+                // If the parameter has a type annotation, exclude it.
+                &current_line[..semi_index]
+            } else {
+                // Otherwise, it's just a list of parameters on the current line.
+                current_line.trim()
+            };
+            // Notably, NumPy lets you put multiple parameters of the same type on the same line.
+            for parameter in parameters.split(',') {
+                docstring_args.insert(parameter.trim());
+            }
+        }
+    }
+    // Validate that all arguments were documented.
+    check_missing_args(checker, definition, docstring_args);
+}
+
 pub fn check_numpy_section(
     checker: &mut Checker,
     definition: &Definition,
     context: &SectionContext,
 ) {
-    // TODO(charlie): Implement `_check_parameters_section`.
     check_common_section(checker, definition, context);
     check_blanks_and_section_underline(checker, definition, context);
 
@@ -381,4 +503,10 @@ pub fn check_numpy_section(
             ))
         }
     }
+
+    if checker.settings.enabled.contains(&CheckCode::D417) {
+        if titlecase(&context.section_name) == "Parameters" {
+            check_parameters_section(checker, definition, context);
+        }
+    }
 }

src/main.rs

@@ -216,7 +216,9 @@ fn inner_main() -> Result<ExitCode> {
         Some(path) => debug!("Found project root at: {:?}", path),
         None => debug!("Unable to identify project root; assuming current directory..."),
     };
-    let pyproject = pyproject::find_pyproject_toml(&project_root);
+    let pyproject = cli
+        .config
+        .or_else(|| pyproject::find_pyproject_toml(&project_root));
     match &pyproject {
         Some(path) => debug!("Found pyproject.toml at: {:?}", path),
         None => debug!("Unable to find pyproject.toml; using default settings..."),

src/snapshots/ruff__linter__tests__C411_C411.py.snap

@@ -2,12 +2,12 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: NoNewLineAtEndOfFile
+- kind: UnnecessaryListCall
   location:
     row: 2
-    column: 9
+    column: 1
   end_location:
     row: 2
-    column: 9
+    column: 21
   fix: ~
 

src/snapshots/ruff__linter__tests__C413_C413.py.snap

@@ -0,0 +1,32 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryCallAroundSorted: list
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 16
+  fix: ~
+- kind:
+    UnnecessaryCallAroundSorted: reversed
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 20
+  fix: ~
+- kind:
+    UnnecessaryCallAroundSorted: reversed
+  location:
+    row: 4
+    column: 1
+  end_location:
+    row: 4
+    column: 34
+  fix: ~
+

src/snapshots/ruff__linter__tests__C416_C416.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    UnnecessaryComprehension: list
+  location:
+    row: 2
+    column: 1
+  end_location:
+    row: 2
+    column: 15
+  fix: ~
+- kind:
+    UnnecessaryComprehension: set
+  location:
+    row: 3
+    column: 1
+  end_location:
+    row: 3
+    column: 15
+  fix: ~
+

src/snapshots/ruff__linter__tests__D214_sections.py.snap

@@ -2,12 +2,13 @@
 source: src/linter.rs
 expression: checks
 ---
-- kind: FitsOnOneLine
+- kind:
+    SectionNotOverIndented: Returns
   location:
-    row: 124
+    row: 135
     column: 5
   end_location:
-    row: 126
+    row: 141
     column: 8
   fix: ~
 

src/snapshots/ruff__linter__tests__D215_sections.py.snap

@@ -0,0 +1,23 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    SectionUnderlineNotOverIndented: Returns
+  location:
+    row: 147
+    column: 5
+  end_location:
+    row: 153
+    column: 8
+  fix: ~
+- kind:
+    SectionUnderlineNotOverIndented: Returns
+  location:
+    row: 161
+    column: 5
+  end_location:
+    row: 165
+    column: 8
+  fix: ~
+

src/snapshots/ruff__linter__tests__D417_sections.py.snap

@@ -0,0 +1,50 @@
+---
+source: src/linter.rs
+expression: checks
+---
+- kind:
+    DocumentAllArguments:
+      - y
+  location:
+    row: 389
+    column: 1
+  end_location:
+    row: 401
+    column: 1
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - test
+      - y
+      - z
+  location:
+    row: 425
+    column: 5
+  end_location:
+    row: 436
+    column: 5
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - test
+      - y
+      - z
+  location:
+    row: 440
+    column: 5
+  end_location:
+    row: 455
+    column: 5
+  fix: ~
+- kind:
+    DocumentAllArguments:
+      - a
+      - z
+  location:
+    row: 459
+    column: 5
+  end_location:
+    row: 471
+    column: 5
+  fix: ~
+