Implement C413 (#421)

src/ast/checkers.rs

@@ -1020,6 +1020,26 @@ pub fn unnecessary_list_call(expr: &Expr, func: &Expr, args: &[Expr]) -> Option<
     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,

src/check_ast.rs

@@ -843,6 +843,13 @@ where
                     };
                 }
 
+                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)

src/checks.rs

@@ -138,6 +138,7 @@ pub enum CheckCode {
     C409,
     C410,
     C411,
+    C413,
     C414,
     C415,
     C416,
@@ -275,6 +276,7 @@ pub enum CheckKind {
     UnnecessaryLiteralWithinTupleCall(String),
     UnnecessaryLiteralWithinListCall(String),
     UnnecessaryListCall,
+    UnnecessaryCallAroundSorted(String),
     UnnecessaryDoubleCastOrProcess(String, String),
     UnnecessarySubscriptReversal(String),
     UnnecessaryComprehension(String),
@@ -419,6 +421,9 @@ impl CheckCode {
                 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(),
@@ -559,6 +564,7 @@ impl CheckKind {
             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,
@@ -827,6 +833,9 @@ 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}().")
             }

src/linter.rs

@@ -1019,6 +1019,18 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn c413() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/C413.py"),
+            &settings::Settings::for_rule(CheckCode::C413),
+            &fixer::Mode::Generate,
+        )?;
+        checks.sort_by_key(|check| check.location);
+        insta::assert_yaml_snapshot!(checks);
+        Ok(())
+    }
+
     #[test]
     fn c414() -> Result<()> {
         let mut checks = check_path(

src/snapshots/ruff__linter__tests__c413.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: ~
+