Implement C411 (#420)

README.md

@@ -215,7 +215,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/) (13/16)
+- [`flake8-comprehensions`](https://pypi.org/project/flake8-comprehensions/) (14/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,6 +293,7 @@ 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() |  |  |
 | 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>() |  |  |

resources/test/fixtures/C411.py

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

src/ast/checkers.rs

@@ -1004,6 +1004,22 @@ 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_double_cast_or_process(
     expr: &Expr,
     func: &Expr,

src/check_ast.rs

@@ -837,6 +837,12 @@ 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::C414) {
                     if let Some(check) =
                         checkers::unnecessary_double_cast_or_process(expr, func, args)

src/checks.rs

@@ -137,6 +137,7 @@ pub enum CheckCode {
     C408,
     C409,
     C410,
+    C411,
     C414,
     C415,
     C416,
@@ -273,6 +274,7 @@ pub enum CheckKind {
     UnnecessaryCollectionCall(String),
     UnnecessaryLiteralWithinTupleCall(String),
     UnnecessaryLiteralWithinListCall(String),
+    UnnecessaryListCall,
     UnnecessaryDoubleCastOrProcess(String, String),
     UnnecessarySubscriptReversal(String),
     UnnecessaryComprehension(String),
@@ -416,6 +418,7 @@ impl CheckCode {
             CheckCode::C410 => {
                 CheckKind::UnnecessaryLiteralWithinListCall("<list/tuple>".to_string())
             }
+            CheckCode::C411 => CheckKind::UnnecessaryListCall,
             CheckCode::C414 => CheckKind::UnnecessaryDoubleCastOrProcess(
                 "<list/reversed/set/sorted/tuple>".to_string(),
                 "<list/set/sorted/tuple>".to_string(),
@@ -555,6 +558,7 @@ impl CheckKind {
             CheckKind::UnnecessaryCollectionCall(_) => &CheckCode::C408,
             CheckKind::UnnecessaryLiteralWithinTupleCall(..) => &CheckCode::C409,
             CheckKind::UnnecessaryLiteralWithinListCall(..) => &CheckCode::C410,
+            CheckKind::UnnecessaryListCall => &CheckCode::C411,
             CheckKind::UnnecessaryDoubleCastOrProcess(..) => &CheckCode::C414,
             CheckKind::UnnecessarySubscriptReversal(_) => &CheckCode::C415,
             CheckKind::UnnecessaryComprehension(..) => &CheckCode::C416,
@@ -820,6 +824,9 @@ impl CheckKind {
                     )
                 }
             }
+            CheckKind::UnnecessaryListCall => {
+                "Unnecessary list call - remove the outer call to list()".to_string()
+            }
             CheckKind::UnnecessaryDoubleCastOrProcess(inner, outer) => {
                 format!("Unnecessary {inner} call within {outer}().")
             }

src/linter.rs

@@ -1007,6 +1007,18 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn c411() -> Result<()> {
+        let mut checks = check_path(
+            Path::new("./resources/test/fixtures/C411.py"),
+            &settings::Settings::for_rule(CheckCode::C411),
+            &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__c411.snap

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