Add rule and autofix to sort the contents of __all__

crates/ruff_linter/resources/test/fixtures/ruff/RUF022.py

@@ -0,0 +1,115 @@
+##################################################
+# Single-line __all__ definitions (nice 'n' easy!)
+##################################################
+
+__all__ = ["d", "c", "b", "a"]  # a comment that is untouched
+__all__ += ["foo", "bar", "antipasti"]
+__all__ = ("d", "c", "b", "a")
+
+if bool():
+    __all__ += ("x", "m", "a", "s")
+else:
+    __all__ += "foo3", "foo2", "foo1"  # NB: an implicit tuple (without parens)
+
+__all__: list[str] = ["the", "three", "little", "pigs"]
+
+####################################
+# Neat multiline __all__ definitions
+####################################
+
+__all__ = (
+    "d0",
+    "c0",  # a comment regarding 'c0'
+    "b0",
+    # a comment regarding 'a0':
+    "a0"
+)
+
+__all__ = [
+    "d",
+    "c",  # a comment regarding 'c'
+    "b",
+    # a comment regarding 'a':
+    "a"
+]
+
+##########################################
+# Messier multiline __all__ definitions...
+##########################################
+
+# comment0
+__all__ = ("d", "a",  # comment1
+           # comment2
+           "f", "b",
+                                        "strangely",  # comment3
+            # comment4
+    "formatted",
+    # comment5
+)  # comment6
+# comment7
+
+__all__ = [  # comment0
+    # comment1
+    # comment2
+    "dx", "cx", "bx", "ax"  # comment3
+    # comment4
+    # comment5
+    # comment6
+]  # comment7
+
+__all__ = ["register", "lookup", "open", "EncodedFile", "BOM", "BOM_BE",
+           "BOM_LE", "BOM32_BE", "BOM32_LE", "BOM64_BE", "BOM64_LE",
+           "BOM_UTF8", "BOM_UTF16", "BOM_UTF16_LE", "BOM_UTF16_BE",
+           "BOM_UTF32", "BOM_UTF32_LE", "BOM_UTF32_BE",
+           "CodecInfo", "Codec", "IncrementalEncoder", "IncrementalDecoder",
+           "StreamReader", "StreamWriter",
+           "StreamReaderWriter", "StreamRecoder",
+           "getencoder", "getdecoder", "getincrementalencoder",
+           "getincrementaldecoder", "getreader", "getwriter",
+           "encode", "decode", "iterencode", "iterdecode",
+           "strict_errors", "ignore_errors", "replace_errors",
+           "xmlcharrefreplace_errors",
+           "backslashreplace_errors", "namereplace_errors",
+           "register_error", "lookup_error"]
+
+###################################
+# These should all not get flagged:
+###################################
+
+__all__ = ()
+__all__ = []
+__all__ = ("single_item",)
+__all__ = ["single_item",]
+__all__ = ("not_a_tuple_just_a_string")
+__all__ = ["a", "b", "c", "d"]
+__all__ += ["e", "f", "g"]
+__all__ = ("a", "b", "c", "d")
+
+if bool():
+    __all__ += ("e", "f", "g")
+else:
+    __all__ += ["alpha", "omega"]
+
+class IntroducesNonModuleScope:
+    __all__ = ("b", "a", "e", "d")
+    __all__ = ["b", "a", "e", "d"]
+    __all__ += ["foo", "bar", "antipasti"]
+
+__all__ = {"look", "a", "set"}
+__all__ = {"very": "strange", "not": "sorted", "we don't": "care"}
+["not", "an", "assignment", "just", "an", "expression"]
+__all__ = (9, 8, 7)
+__all__ = ("don't" "care" "about", "__all__" "with", "concatenated" "strings")
+
+__all__ = (
+    "look",
+    (
+        "a_veeeeeeeeeeeeeeeeeeery_long_parenthesized_item_we_dont_care_about"
+    ),
+)
+
+__all__ = (  # This is just an empty tuple,
+    # but,
+    # it's very well
+)  # documented
+

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

@@ -1065,12 +1065,15 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
                 pylint::rules::misplaced_bare_raise(checker, raise);
             }
         }
-        Stmt::AugAssign(ast::StmtAugAssign { target, .. }) => {
+        Stmt::AugAssign(aug_assign @ ast::StmtAugAssign { target, .. }) => {
             if checker.enabled(Rule::GlobalStatement) {
                 if let Expr::Name(ast::ExprName { id, .. }) = target.as_ref() {
                     pylint::rules::global_statement(checker, id);
                 }
             }
+            if checker.enabled(Rule::UnsortedDunderAll) {
+                ruff::rules::sort_dunder_all_aug_assign(checker, aug_assign, stmt);
+            }
         }
         Stmt::If(
             if_ @ ast::StmtIf {
@@ -1457,6 +1460,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.settings.rules.enabled(Rule::TypeBivariance) {
                 pylint::rules::type_bivariance(checker, value);
             }
+            if checker.settings.rules.enabled(Rule::UnsortedDunderAll) {
+                ruff::rules::sort_dunder_all_assign(checker, assign, stmt);
+            }
             if checker.source_type.is_stub() {
                 if checker.any_enabled(&[
                     Rule::UnprefixedTypeParam,
@@ -1527,6 +1533,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::NonPEP695TypeAlias) {
                 pyupgrade::rules::non_pep695_type_alias(checker, assign_stmt);
             }
+            if checker.settings.rules.enabled(Rule::UnsortedDunderAll) {
+                ruff::rules::sort_dunder_all_ann_assign(checker, assign_stmt, stmt);
+            }
             if checker.source_type.is_stub() {
                 if let Some(value) = value {
                     if checker.enabled(Rule::AssignmentDefaultInStub) {

crates/ruff_linter/src/codes.rs

@@ -925,6 +925,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Ruff, "019") => (RuleGroup::Preview, rules::ruff::rules::UnnecessaryKeyCheck),
         (Ruff, "020") => (RuleGroup::Preview, rules::ruff::rules::NeverUnion),
         (Ruff, "021") => (RuleGroup::Preview, rules::ruff::rules::ParenthesizeChainedOperators),
+        (Ruff, "022") => (RuleGroup::Preview, rules::ruff::rules::UnsortedDunderAll),
         (Ruff, "100") => (RuleGroup::Stable, rules::ruff::rules::UnusedNOQA),
         (Ruff, "200") => (RuleGroup::Stable, rules::ruff::rules::InvalidPyprojectToml),
 

crates/ruff_linter/src/rules/ruff/mod.rs

@@ -47,6 +47,7 @@ mod tests {
     #[test_case(Rule::UnnecessaryKeyCheck, Path::new("RUF019.py"))]
     #[test_case(Rule::NeverUnion, Path::new("RUF020.py"))]
     #[test_case(Rule::ParenthesizeChainedOperators, Path::new("RUF021.py"))]
+    #[test_case(Rule::UnsortedDunderAll, Path::new("RUF022.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = format!("{}_{}", rule_code.noqa_code(), path.to_string_lossy());
         let diagnostics = test_path(

crates/ruff_linter/src/rules/ruff/rules/mod.rs

@@ -13,6 +13,7 @@ pub(crate) use never_union::*;
 pub(crate) use pairwise_over_zipped::*;
 pub(crate) use parenthesize_logical_operators::*;
 pub(crate) use quadratic_list_summation::*;
+pub(crate) use sort_dunder_all::*;
 pub(crate) use static_key_dict_comprehension::*;
 pub(crate) use unnecessary_iterable_allocation_for_first_element::*;
 pub(crate) use unnecessary_key_check::*;
@@ -36,6 +37,7 @@ mod mutable_dataclass_default;
 mod never_union;
 mod pairwise_over_zipped;
 mod parenthesize_logical_operators;
+mod sort_dunder_all;
 mod static_key_dict_comprehension;
 mod unnecessary_iterable_allocation_for_first_element;
 mod unnecessary_key_check;