Bump version to 0.0.99

.github/workflows/flake8-to-ruff.yaml

@@ -30,7 +30,7 @@ jobs:
         uses: messense/maturin-action@v1
         with:
           target: x86_64
-          args: --release --out dist --sdist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist --sdist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - name: Install built wheel - x86_64
         run: |
@@ -57,7 +57,7 @@ jobs:
       - name: Build wheels - universal2
         uses: messense/maturin-action@v1
         with:
-          args: --release --universal2 --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --universal2 --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - name: Install built wheel - universal2
         run: |
@@ -89,7 +89,7 @@ jobs:
         uses: messense/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          args: --release --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - name: Install built wheel
         shell: bash
@@ -117,7 +117,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --release --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - name: Install built wheel
         if: matrix.target == 'x86_64'
@@ -144,7 +144,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --no-default-features --release --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --no-default-features --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - uses: uraimo/run-on-arch-action@v2.0.5
         if: matrix.target != 'ppc64'
@@ -183,7 +183,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: musllinux_1_2
-          args: --release --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - name: Install built wheel
         if: matrix.target == 'x86_64-unknown-linux-musl'
@@ -219,7 +219,7 @@ jobs:
         with:
           target: ${{ matrix.platform.target }}
           manylinux: musllinux_1_2
-          args: --release --out dist -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist -m ./${{ env.CRATE_NAME }}/Cargo.toml
           maturin-version: "v0.13.0"
       - uses: uraimo/run-on-arch-action@master
         name: Install built wheel
@@ -261,7 +261,7 @@ jobs:
           maturin-version: "v0.13.0"
           target: ${{ matrix.target }}
           manylinux: auto
-          args: --release --out dist -i pypy${{ matrix.python-version }} -m ./crates/${{ env.CRATE_NAME }}/Cargo.toml
+          args: --release --out dist -i pypy${{ matrix.python-version }} -m ./${{ env.CRATE_NAME }}/Cargo.toml
       - name: Install built wheel
         if: matrix.target == 'x86_64'
         run: |

.pre-commit-config.yaml

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

Cargo.lock

@@ -920,7 +920,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8-to-ruff"
-version = "0.0.97-dev.0"
+version = "0.0.99-dev.0"
 dependencies = [
  "anyhow",
  "clap 4.0.15",
@@ -2211,7 +2211,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.97"
+version = "0.0.99"
 dependencies = [
  "anyhow",
  "assert_cmd",

Cargo.toml

@@ -1,11 +1,11 @@
 [workspace]
 members = [
-  "crates/flake8_to_ruff",
+    "flake8_to_ruff",
 ]
 
 [package]
 name = "ruff"
-version = "0.0.97"
+version = "0.0.99"
 edition = "2021"
 
 [lib]

README.md

@@ -89,7 +89,7 @@ Ruff also works with [pre-commit](https://pre-commit.com):
 ```yaml
 repos:
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.97
+    rev: v0.0.99
     hooks:
       - id: ruff
 ```
@@ -99,15 +99,59 @@ _Note: prior to `v0.0.86`, `ruff-pre-commit` used `lint` (rather than `ruff`) as
 
 ## Configuration
 
-Ruff is configurable both via `pyproject.toml` and the command line.
-
-For example, you could configure Ruff to only enforce a subset of rules with:
+Ruff is configurable both via `pyproject.toml` and the command line. If left unspecified, the
+default configuration is equivalent to:
 
 ```toml
 [tool.ruff]
 line-length = 88
+
+# Enable Flake's "E" and "F" codes by default.
 select = ["E", "F"]
+ignore = []
+
+# Exclude a variety of commonly ignored directories.
+exclude = [
+    ".bzr",
+    ".direnv",
+    ".eggs",
+    ".git",
+    ".hg",
+    ".mypy_cache",
+    ".nox",
+    ".pants.d",
+    ".ruff_cache",
+    ".svn",
+    ".tox",
+    ".venv",
+    "__pypackages__",
+    "_build",
+    "buck-out",
+    "build",
+    "dist",
+    "node_modules",
+    "venv",
+]
+per-file-ignores = {}
+
+# Allow unused variables when underscore-prefixed.
+dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
+
+# Assume Python 3.10.
+target-version = "py310"
+```
+
+As an example, the following would configure Ruff to (1) avoid checking for line-length
+violations (`E501`) and (2) ignore unused import rules in `__init__.py` files:
+
+```toml
+[tool.ruff]
+select = ["E", "F"]
+
+# Never enforce `E501`.
 ignore = ["E501"]
+
+# Ignore `F401` violations in any `__init__.py` file, and in `path/to/file.py`.
 per-file-ignores = {"__init__.py" = ["F401"], "path/to/file.py" = ["F401"]}
 ```
 
@@ -115,7 +159,8 @@ Plugin configurations should be expressed as subsections, e.g.:
 
 ```toml
 [tool.ruff]
-line-length = 88
+# Add "Q" to the list of enabled codes.
+select = ["E", "F", "Q"]
 
 [tool.ruff.flake8-quotes]
 docstring-quotes = "double"
@@ -143,6 +188,8 @@ Options:
   -v, --verbose
           Enable verbose logging
   -q, --quiet
+          Only log errors
+  -s, --silent
           Disable all logging (but still exit with status code "1" upon detecting errors)
   -e, --exit-zero
           Exit with status code "0", even upon detecting errors
@@ -398,7 +445,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | C403 | UnnecessaryListComprehensionSet | Unnecessary `list` comprehension (rewrite as a `set` comprehension) | 🛠 |
 | C404 | UnnecessaryListComprehensionDict | Unnecessary `list` comprehension (rewrite as a `dict` comprehension) |  |
 | C405 | UnnecessaryLiteralSet | Unnecessary `(list\|tuple)` literal (rewrite as a `set` literal) | 🛠 |
-| C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) |  |
+| C406 | UnnecessaryLiteralDict | Unnecessary `(list\|tuple)` literal (rewrite as a `dict` literal) | 🛠 |
 | 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) | 🛠 |
@@ -406,7 +453,7 @@ The 🛠 emoji indicates that a rule is automatically fixable by the `--fix` com
 | 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)()`) |  |
+| C416 | UnnecessaryComprehension | Unnecessary `(list\|set)` comprehension (rewrite using `(list\|set)()`) | 🛠 |
 | C417 | UnnecessaryMap | Unnecessary `map` usage (rewrite using a `(list\|set\|dict)` comprehension) |  |
 
 ### flake8-bugbear

flake8_to_ruff/Cargo.lock

@@ -771,7 +771,7 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
 
 [[package]]
 name = "flake8_to_ruff"
-version = "0.0.97"
+version = "0.0.99"
 dependencies = [
  "anyhow",
  "clap",
@@ -1410,7 +1410,7 @@ dependencies = [
 name = "net2"
 version = "0.2.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d0df99cfcd2530b2e694f6e17e7f37b8e26bb23983ac530c0c97408837c631"
+checksum = "74d0df99cfcd2530b2e694f6e17e7f37b8e26bb23983ac530.0.98408837c631"
 dependencies = [
  "cfg-if 0.1.10",
  "libc",
@@ -1975,7 +1975,7 @@ dependencies = [
 
 [[package]]
 name = "ruff"
-version = "0.0.97"
+version = "0.0.99"
 dependencies = [
  "anyhow",
  "bincode",

flake8_to_ruff/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "flake8-to-ruff"
-version = "0.0.97-dev.0"
+version = "0.0.99-dev.0"
 edition = "2021"
 
 [lib]
@@ -12,7 +12,7 @@ clap = { version = "4.0.1", features = ["derive"] }
 configparser = { version = "3.0.2" }
 once_cell = { version = "1.13.1" }
 regex = { version = "1.6.0" }
-ruff = { path = "../..", default-features = false }
+ruff = { path = "..", default-features = false }
 serde = { version = "1.0.143", features = ["derive"] }
 serde_json = { version = "1.0.83" }
 toml = { version = "0.5.9" }

src/check_ast.rs

@@ -1076,9 +1076,12 @@ where
 
                 if self.settings.enabled.contains(&CheckCode::C406) {
                     if let Some(check) = flake8_comprehensions::checks::unnecessary_literal_dict(
+                        expr,
                         func,
                         args,
                         keywords,
+                        self.locator,
+                        self.patch(),
                         self.locate_check(Range::from_located(expr)),
                     ) {
                         self.checks.push(check);
@@ -1363,6 +1366,8 @@ where
                         expr,
                         elt,
                         generators,
+                        self.locator,
+                        self.patch(),
                         self.locate_check(Range::from_located(expr)),
                     ) {
                         self.checks.push(check);

src/checks.rs

@@ -1470,11 +1470,13 @@ impl CheckKind {
                 | CheckKind::TypeOfPrimitive(_)
                 | CheckKind::UnnecessaryAbspath
                 | CheckKind::UnnecessaryCollectionCall(_)
+                | CheckKind::UnnecessaryComprehension(_)
                 | CheckKind::UnnecessaryGeneratorDict
                 | CheckKind::UnnecessaryGeneratorList
                 | CheckKind::UnnecessaryGeneratorSet
                 | CheckKind::UnnecessaryListCall
                 | CheckKind::UnnecessaryListComprehensionSet
+                | CheckKind::UnnecessaryLiteralDict(_)
                 | CheckKind::UnnecessaryLiteralSet(_)
                 | CheckKind::UnnecessaryLiteralWithinListCall(_)
                 | CheckKind::UnnecessaryLiteralWithinTupleCall(_)

src/cli.rs

@@ -7,6 +7,7 @@ use log::warn;
 use regex::Regex;
 
 use crate::checks_gen::CheckCodePrefix;
+use crate::logging::LogLevel;
 use crate::printer::SerializationFormat;
 use crate::settings::configuration::Configuration;
 use crate::settings::types::{PatternPrefixPair, PythonVersion};
@@ -93,6 +94,19 @@ pub struct Cli {
     pub stdin_filename: Option<String>,
 }
 
+/// Map the CLI settings to a `LogLevel`.
+pub fn extract_log_level(cli: &Cli) -> LogLevel {
+    if cli.silent {
+        LogLevel::Silent
+    } else if cli.quiet {
+        LogLevel::Quiet
+    } else if cli.verbose {
+        LogLevel::Verbose
+    } else {
+        LogLevel::Default
+    }
+}
+
 pub enum Warnable {
     Select,
     ExtendSelect,

src/flake8_comprehensions/checks.rs

@@ -197,9 +197,12 @@ pub fn unnecessary_literal_set(
 
 /// C406 (`dict([(1, 2)])`)
 pub fn unnecessary_literal_dict(
+    expr: &Expr,
     func: &Expr,
     args: &[Expr],
     keywords: &[Keyword],
+    locator: &SourceCodeLocator,
+    fix: bool,
     location: Range,
 ) -> Option<Check> {
     let argument = exactly_one_argument_with_matching_function("dict", func, args, keywords)?;
@@ -208,18 +211,24 @@ pub fn unnecessary_literal_dict(
         ExprKind::List { elts, .. } => ("list", elts),
         _ => return None,
     };
-
-    if let Some(elt) = elts.first() {
-        // dict((1, 2), ...)) or dict([(1, 2), ...])
-        if !matches!(&elt.node, ExprKind::Tuple { elts, .. } if elts.len() == 2) {
-            return None;
-        }
+    // Accept `dict((1, 2), ...))` `dict([(1, 2), ...])`.
+    if !elts
+        .iter()
+        .all(|elt| matches!(&elt.node, ExprKind::Tuple { elts, .. } if elts.len() == 2))
+    {
+        return None;
     }
-
-    Some(Check::new(
+    let mut check = Check::new(
         CheckKind::UnnecessaryLiteralDict(kind.to_string()),
         location,
-    ))
+    );
+    if fix {
+        match fixes::fix_unnecessary_literal_dict(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }
 
 /// C408
@@ -250,12 +259,9 @@ pub fn unnecessary_collection_call(
         location,
     );
     if fix {
-        // TODO(charlie): Support fixing `dict(a=1)`.
-        if keywords.is_empty() {
-            match fixes::fix_unnecessary_collection_call(locator, expr) {
-                Ok(fix) => check.amend(fix),
-                Err(e) => error!("Failed to generate fix: {}", e),
-            }
+        match fixes::fix_unnecessary_collection_call(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
         }
     }
     Some(check)
@@ -446,6 +452,8 @@ pub fn unnecessary_comprehension(
     expr: &Expr,
     elt: &Expr,
     generators: &[Comprehension],
+    locator: &SourceCodeLocator,
+    fix: bool,
     location: Range,
 ) -> Option<Check> {
     if generators.len() != 1 {
@@ -465,10 +473,17 @@ pub fn unnecessary_comprehension(
         ExprKind::SetComp { .. } => "set",
         _ => return None,
     };
-    Some(Check::new(
+    let mut check = Check::new(
         CheckKind::UnnecessaryComprehension(expr_kind.to_string()),
         location,
-    ))
+    );
+    if fix {
+        match fixes::fix_unnecessary_comprehension(locator, expr) {
+            Ok(fix) => check.amend(fix),
+            Err(e) => error!("Failed to generate fix: {}", e),
+        }
+    }
+    Some(check)
 }
 
 /// C417

src/flake8_comprehensions/fixes.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
 use libcst_native::{
-    Arg, Call, Codegen, Dict, DictComp, Element, Expr, Expression, LeftCurlyBrace, LeftParen,
-    LeftSquareBracket, List, ListComp, Module, ParenthesizableWhitespace, RightCurlyBrace,
-    RightParen, RightSquareBracket, Set, SetComp, SimpleWhitespace, SmallStatement, Statement,
-    Tuple,
+    Arg, Call, Codegen, Dict, DictComp, DictElement, Element, Expr, Expression, LeftCurlyBrace,
+    LeftParen, LeftSquareBracket, List, ListComp, Module, Name, ParenthesizableWhitespace,
+    RightCurlyBrace, RightParen, RightSquareBracket, Set, SetComp, SimpleString, SimpleWhitespace,
+    SmallStatement, Statement, Tuple,
 };
 
 use crate::autofix::Fix;
@@ -15,12 +15,10 @@ fn match_expr<'a, 'b>(module: &'a mut Module<'b>) -> Result<&'a mut Expr<'b>> {
         if let Some(SmallStatement::Expr(expr)) = expr.body.first_mut() {
             Ok(expr)
         } else {
-            Err(anyhow::anyhow!(
-                "Expected node to be: SmallStatement::Expr."
-            ))
+            Err(anyhow::anyhow!("Expected node to be: SmallStatement::Expr"))
         }
     } else {
-        Err(anyhow::anyhow!("Expected node to be: Statement::Simple."))
+        Err(anyhow::anyhow!("Expected node to be: Statement::Simple"))
     }
 }
 
@@ -28,7 +26,7 @@ fn match_call<'a, 'b>(expr: &'a mut Expr<'b>) -> Result<&'a mut Call<'b>> {
     if let Expression::Call(call) = &mut expr.value {
         Ok(call)
     } else {
-        Err(anyhow::anyhow!("Expected node to be: Expression::Call."))
+        Err(anyhow::anyhow!("Expected node to be: Expression::Call"))
     }
 }
 
@@ -36,7 +34,7 @@ fn match_arg<'a, 'b>(call: &'a Call<'b>) -> Result<&'a Arg<'b>> {
     if let Some(arg) = call.args.first() {
         Ok(arg)
     } else {
-        Err(anyhow::anyhow!("Expected node to be: Arg."))
+        Err(anyhow::anyhow!("Expected node to be: Arg"))
     }
 }
 
@@ -55,7 +53,7 @@ pub fn fix_unnecessary_generator_list(
         generator_exp
     } else {
         return Err(anyhow::anyhow!(
-            "Expected node to be: Expression::GeneratorExp."
+            "Expected node to be: Expression::GeneratorExp"
         ));
     };
 
@@ -97,7 +95,7 @@ pub fn fix_unnecessary_generator_set(
         generator_exp
     } else {
         return Err(anyhow::anyhow!(
-            "Expected node to be: Expression::GeneratorExp."
+            "Expected node to be: Expression::GeneratorExp"
         ));
     };
 
@@ -140,26 +138,26 @@ pub fn fix_unnecessary_generator_dict(
         generator_exp
     } else {
         return Err(anyhow::anyhow!(
-            "Expected node to be: Expression::GeneratorExp."
+            "Expected node to be: Expression::GeneratorExp"
         ));
     };
     let tuple = if let Expression::Tuple(tuple) = &generator_exp.elt.as_ref() {
         tuple
     } else {
-        return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple."));
+        return Err(anyhow::anyhow!("Expected node to be: Expression::Tuple"));
     };
     let key = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(0) {
         value
     } else {
         return Err(anyhow::anyhow!(
-            "Expected tuple to contain a key as the first element."
+            "Expected tuple to contain a key as the first element"
         ));
     };
     let value = if let Some(Element::Simple { value, .. }) = &tuple.elements.get(1) {
         value
     } else {
         return Err(anyhow::anyhow!(
-            "Expected tuple to contain a key as the second element."
+            "Expected tuple to contain a key as the second element"
         ));
     };
 
@@ -204,9 +202,7 @@ pub fn fix_unnecessary_list_comprehension_set(
     let list_comp = if let Expression::ListComp(list_comp) = &arg.value {
         list_comp
     } else {
-        return Err(anyhow::anyhow!(
-            "Expected node to be: Expression::ListComp."
-        ));
+        return Err(anyhow::anyhow!("Expected node to be: Expression::ListComp"));
     };
 
     body.value = Expression::SetComp(Box::new(SetComp {
@@ -248,7 +244,7 @@ pub fn fix_unnecessary_literal_set(
         Expression::List(inner) => &inner.elements,
         _ => {
             return Err(anyhow::anyhow!(
-                "Expected node to be: Expression::Tuple | Expression::List."
+                "Expected node to be: Expression::Tuple | Expression::List"
             ))
         }
     };
@@ -279,6 +275,77 @@ pub fn fix_unnecessary_literal_set(
     ))
 }
 
+/// (C406) Convert `dict([(1, 2)])` to `{1: 2}`.
+pub fn fix_unnecessary_literal_dict(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    // Expr(Call(List|Tuple)))) -> Expr(Dict)))
+    let mut tree = match_tree(locator, expr)?;
+    let mut body = match_expr(&mut tree)?;
+    let call = match_call(body)?;
+    let arg = match_arg(call)?;
+
+    let elements = match &arg.value {
+        Expression::Tuple(inner) => &inner.elements,
+        Expression::List(inner) => &inner.elements,
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::Tuple | Expression::List"
+            ))
+        }
+    };
+
+    let elements: Vec<DictElement> = elements
+        .iter()
+        .map(|element| {
+            if let Element::Simple {
+                value: Expression::Tuple(tuple),
+                comma,
+            } = element
+            {
+                if let Some(Element::Simple { value: key, .. }) = tuple.elements.get(0) {
+                    if let Some(Element::Simple { value, .. }) = tuple.elements.get(1) {
+                        return Ok(DictElement::Simple {
+                            key: key.clone(),
+                            value: value.clone(),
+                            comma: comma.clone(),
+                            whitespace_before_colon: Default::default(),
+                            whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
+                                SimpleWhitespace(" "),
+                            ),
+                        });
+                    }
+                }
+            }
+            Err(anyhow::anyhow!(
+                "Expected each argument to be a tuple of length two"
+            ))
+        })
+        .collect::<Result<Vec<DictElement>>>()?;
+
+    body.value = Expression::Dict(Box::new(Dict {
+        elements,
+        lbrace: LeftCurlyBrace {
+            whitespace_after: call.whitespace_before_args.clone(),
+        },
+        rbrace: RightCurlyBrace {
+            whitespace_before: arg.whitespace_after_arg.clone(),
+        },
+        lpar: Default::default(),
+        rpar: Default::default(),
+    }));
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}
+
 /// (C408)
 pub fn fix_unnecessary_collection_call(
     locator: &SourceCodeLocator,
@@ -291,9 +358,13 @@ pub fn fix_unnecessary_collection_call(
     let name = if let Expression::Name(name) = &call.func.as_ref() {
         name
     } else {
-        return Err(anyhow::anyhow!("Expected node to be: Expression::Name."));
+        return Err(anyhow::anyhow!("Expected node to be: Expression::Name"));
     };
 
+    // Arena allocator used to create formatted strings of sufficient lifetime,
+    // below.
+    let mut arena: Vec<String> = vec![];
+
     match name.value {
         "tuple" => {
             body.value = Expression::Tuple(Box::new(Tuple {
@@ -312,17 +383,67 @@ pub fn fix_unnecessary_collection_call(
             }));
         }
         "dict" => {
-            body.value = Expression::Dict(Box::new(Dict {
-                elements: Default::default(),
-                lbrace: Default::default(),
-                rbrace: Default::default(),
-                lpar: Default::default(),
-                rpar: Default::default(),
-            }));
+            if call.args.is_empty() {
+                body.value = Expression::Dict(Box::new(Dict {
+                    elements: Default::default(),
+                    lbrace: Default::default(),
+                    rbrace: Default::default(),
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }));
+            } else {
+                // Quote each argument.
+                for arg in &call.args {
+                    let quoted = format!(
+                        "\"{}\"",
+                        arg.keyword
+                            .as_ref()
+                            .expect("Expected dictionary argument to be kwarg")
+                            .value
+                    );
+                    arena.push(quoted);
+                }
+
+                let elements = call
+                    .args
+                    .iter()
+                    .enumerate()
+                    .map(|(i, arg)| DictElement::Simple {
+                        key: Expression::SimpleString(Box::new(SimpleString {
+                            value: &arena[i],
+                            lpar: Default::default(),
+                            rpar: Default::default(),
+                        })),
+                        value: arg.value.clone(),
+                        comma: arg.comma.clone(),
+                        whitespace_before_colon: Default::default(),
+                        whitespace_after_colon: ParenthesizableWhitespace::SimpleWhitespace(
+                            SimpleWhitespace(" "),
+                        ),
+                    })
+                    .collect();
+
+                body.value = Expression::Dict(Box::new(Dict {
+                    elements,
+                    lbrace: LeftCurlyBrace {
+                        whitespace_after: call.whitespace_before_args.clone(),
+                    },
+                    rbrace: RightCurlyBrace {
+                        whitespace_before: call
+                            .args
+                            .last()
+                            .expect("Arguments should be non-empty")
+                            .whitespace_after_arg
+                            .clone(),
+                    },
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }));
+            }
         }
         _ => {
             return Err(anyhow::anyhow!("Expected function name to be one of: \
-                                        'tuple', 'list', 'dict'."
+                                        'tuple', 'list', 'dict'"
                 .to_string()));
         }
     };
@@ -352,12 +473,12 @@ pub fn fix_unnecessary_literal_within_tuple_call(
             &inner
                 .lpar
                 .first()
-                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses."))?
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
                 .whitespace_after,
             &inner
                 .rpar
                 .first()
-                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses."))?
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
                 .whitespace_before,
         ),
         Expression::List(inner) => (
@@ -367,7 +488,7 @@ pub fn fix_unnecessary_literal_within_tuple_call(
         ),
         _ => {
             return Err(anyhow::anyhow!(
-                "Expected node to be: Expression::Tuple | Expression::List."
+                "Expected node to be: Expression::Tuple | Expression::List"
             ))
         }
     };
@@ -407,12 +528,12 @@ pub fn fix_unnecessary_literal_within_list_call(
             &inner
                 .lpar
                 .first()
-                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses."))?
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
                 .whitespace_after,
             &inner
                 .rpar
                 .first()
-                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses."))?
+                .ok_or_else(|| anyhow::anyhow!("Expected at least one set of parentheses"))?
                 .whitespace_before,
         ),
         Expression::List(inner) => (
@@ -422,7 +543,7 @@ pub fn fix_unnecessary_literal_within_list_call(
         ),
         _ => {
             return Err(anyhow::anyhow!(
-                "Expected node to be: Expression::Tuple | Expression::List."
+                "Expected node to be: Expression::Tuple | Expression::List"
             ))
         }
     };
@@ -449,7 +570,7 @@ pub fn fix_unnecessary_literal_within_list_call(
     ))
 }
 
-/// (C411) Convert `list([i for i in x])` to `[i for i in x]`.
+/// (C411) Convert `list([i * i for i in x])` to `[i * i for i in x]`.
 pub fn fix_unnecessary_list_call(
     locator: &SourceCodeLocator,
     expr: &rustpython_ast::Expr,
@@ -471,3 +592,73 @@ pub fn fix_unnecessary_list_call(
         expr.end_location.unwrap(),
     ))
 }
+
+/// (C416) Convert `[i for i in x]` to `list(x)`.
+pub fn fix_unnecessary_comprehension(
+    locator: &SourceCodeLocator,
+    expr: &rustpython_ast::Expr,
+) -> Result<Fix> {
+    let mut tree = match_tree(locator, expr)?;
+    let mut body = match_expr(&mut tree)?;
+
+    match &body.value {
+        Expression::ListComp(inner) => {
+            body.value = Expression::Call(Box::new(Call {
+                func: Box::new(Expression::Name(Box::new(Name {
+                    value: "list",
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }))),
+                args: vec![Arg {
+                    value: inner.for_in.iter.clone(),
+                    keyword: Default::default(),
+                    equal: Default::default(),
+                    comma: Default::default(),
+                    star: Default::default(),
+                    whitespace_after_star: Default::default(),
+                    whitespace_after_arg: Default::default(),
+                }],
+                lpar: Default::default(),
+                rpar: Default::default(),
+                whitespace_after_func: Default::default(),
+                whitespace_before_args: Default::default(),
+            }))
+        }
+        Expression::SetComp(inner) => {
+            body.value = Expression::Call(Box::new(Call {
+                func: Box::new(Expression::Name(Box::new(Name {
+                    value: "set",
+                    lpar: Default::default(),
+                    rpar: Default::default(),
+                }))),
+                args: vec![Arg {
+                    value: inner.for_in.iter.clone(),
+                    keyword: Default::default(),
+                    equal: Default::default(),
+                    comma: Default::default(),
+                    star: Default::default(),
+                    whitespace_after_star: Default::default(),
+                    whitespace_after_arg: Default::default(),
+                }],
+                lpar: Default::default(),
+                rpar: Default::default(),
+                whitespace_after_func: Default::default(),
+                whitespace_before_args: Default::default(),
+            }))
+        }
+        _ => {
+            return Err(anyhow::anyhow!(
+                "Expected node to be: Expression::ListComp | Expression:SetComp"
+            ))
+        }
+    }
+
+    let mut state = Default::default();
+    tree.codegen(&mut state);
+
+    Ok(Fix::replacement(
+        state.to_string(),
+        expr.location,
+        expr.end_location.unwrap(),
+    ))
+}

src/logging.rs

@@ -15,7 +15,36 @@ macro_rules! tell_user {
     }
 }
 
-pub fn set_up_logging(verbose: bool) -> Result<()> {
+#[derive(Debug, PartialOrd, Ord, PartialEq, Eq)]
+pub enum LogLevel {
+    // No output (+ `log::LevelFilter::Off`).
+    Silent,
+    // Only show lint violations, with no decorative output (+ `log::LevelFilter::Off`).
+    Quiet,
+    // All user-facing output (+ `log::LevelFilter::Info`).
+    Default,
+    // All user-facing output (+ `log::LevelFilter::Debug`).
+    Verbose,
+}
+
+impl LogLevel {
+    fn level_filter(&self) -> log::LevelFilter {
+        match self {
+            LogLevel::Default => log::LevelFilter::Info,
+            LogLevel::Verbose => log::LevelFilter::Debug,
+            LogLevel::Quiet => log::LevelFilter::Off,
+            LogLevel::Silent => log::LevelFilter::Off,
+        }
+    }
+}
+
+impl Default for LogLevel {
+    fn default() -> Self {
+        LogLevel::Default
+    }
+}
+
+pub fn set_up_logging(level: &LogLevel) -> Result<()> {
     fern::Dispatch::new()
         .format(|out, message, record| {
             out.finish(format_args!(
@@ -26,12 +55,22 @@ pub fn set_up_logging(verbose: bool) -> Result<()> {
                 message
             ))
         })
-        .level(if verbose {
-            log::LevelFilter::Debug
-        } else {
-            log::LevelFilter::Info
-        })
+        .level(level.level_filter())
         .chain(std::io::stdout())
         .apply()
         .map_err(|e| e.into())
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::logging::LogLevel;
+
+    #[test]
+    fn ordering() {
+        assert!(LogLevel::Default > LogLevel::Silent);
+        assert!(LogLevel::Default >= LogLevel::Default);
+        assert!(LogLevel::Quiet > LogLevel::Silent);
+        assert!(LogLevel::Verbose > LogLevel::Default);
+        assert!(LogLevel::Verbose > LogLevel::Silent);
+    }
+}

src/main.rs

@@ -5,6 +5,20 @@ use std::process::ExitCode;
 use std::sync::mpsc::channel;
 use std::time::Instant;
 
+#[cfg(not(target_family = "wasm"))]
+use ::ruff::cache;
+use ::ruff::checks::{CheckCode, CheckKind};
+use ::ruff::checks_gen::CheckCodePrefix;
+use ::ruff::cli::{collect_per_file_ignores, extract_log_level, warn_on, Cli, Warnable};
+use ::ruff::fs::iter_python_files;
+use ::ruff::linter::{add_noqa_to_path, autoformat_path, lint_path, lint_stdin};
+use ::ruff::logging::{set_up_logging, LogLevel};
+use ::ruff::message::Message;
+use ::ruff::printer::{Printer, SerializationFormat};
+use ::ruff::settings::configuration::Configuration;
+use ::ruff::settings::types::FilePattern;
+use ::ruff::settings::user::UserConfiguration;
+use ::ruff::settings::{pyproject, Settings};
 use anyhow::Result;
 use clap::Parser;
 use colored::Colorize;
@@ -12,21 +26,6 @@ use log::{debug, error};
 use notify::{raw_watcher, RecursiveMode, Watcher};
 #[cfg(not(target_family = "wasm"))]
 use rayon::prelude::*;
-#[cfg(not(target_family = "wasm"))]
-use ruff::cache;
-use ruff::checks::{CheckCode, CheckKind};
-use ruff::checks_gen::CheckCodePrefix;
-use ruff::cli::{collect_per_file_ignores, warn_on, Cli, Warnable};
-use ruff::fs::iter_python_files;
-use ruff::linter::{add_noqa_to_path, autoformat_path, lint_path, lint_stdin};
-use ruff::logging::set_up_logging;
-use ruff::message::Message;
-use ruff::printer::{Printer, SerializationFormat};
-use ruff::settings::configuration::Configuration;
-use ruff::settings::types::FilePattern;
-use ruff::settings::user::UserConfiguration;
-use ruff::settings::{pyproject, Settings};
-use ruff::tell_user;
 use walkdir::DirEntry;
 
 #[cfg(feature = "update-informer")]
@@ -223,10 +222,10 @@ fn autoformat(files: &[PathBuf], settings: &Settings) -> Result<usize> {
 }
 
 fn inner_main() -> Result<ExitCode> {
-    let mut cli = Cli::parse();
-    cli.quiet |= cli.silent;
+    let cli = Cli::parse();
 
-    set_up_logging(cli.verbose)?;
+    let log_level = extract_log_level(&cli);
+    set_up_logging(&log_level)?;
 
     // Find the project root and pyproject.toml.
     let project_root = pyproject::find_project_root(&cli.files);
@@ -320,7 +319,7 @@ fn inner_main() -> Result<ExitCode> {
     #[cfg(not(target_family = "wasm"))]
     cache::init()?;
 
-    let mut printer = Printer::new(cli.format, cli.verbose);
+    let printer = Printer::new(&cli.format, &log_level);
     if cli.watch {
         if cli.fix {
             eprintln!("Warning: --fix is not enabled in watch mode.");
@@ -340,12 +339,10 @@ fn inner_main() -> Result<ExitCode> {
 
         // Perform an initial run instantly.
         printer.clear_screen()?;
-        tell_user!("Starting linter in watch mode...\n");
+        printer.write_to_user("Starting linter in watch mode...\n");
 
         let messages = run_once(&cli.files, &settings, !cli.no_cache, false)?;
-        if !cli.silent {
-            printer.write_continuously(&messages)?;
-        }
+        printer.write_continuously(&messages)?;
 
         // Configure the file watcher.
         let (tx, rx) = channel();
@@ -360,12 +357,10 @@ fn inner_main() -> Result<ExitCode> {
                     if let Some(path) = e.path {
                         if path.to_string_lossy().ends_with(".py") {
                             printer.clear_screen()?;
-                            tell_user!("File change detected...\n");
+                            printer.write_to_user("File change detected...\n");
 
                             let messages = run_once(&cli.files, &settings, !cli.no_cache, false)?;
-                            if !cli.silent {
-                                printer.write_continuously(&messages)?;
-                            }
+                            printer.write_continuously(&messages)?;
                         }
                     }
                 }
@@ -374,37 +369,36 @@ fn inner_main() -> Result<ExitCode> {
         }
     } else if cli.add_noqa {
         let modifications = add_noqa(&cli.files, &settings)?;
-        if modifications > 0 {
+        if modifications > 0 && log_level >= LogLevel::Default {
             println!("Added {modifications} noqa directives.");
         }
     } else if cli.autoformat {
         let modifications = autoformat(&cli.files, &settings)?;
-        if modifications > 0 {
+        if modifications > 0 && log_level >= LogLevel::Default {
             println!("Formatted {modifications} files.");
         }
     } else {
-        let (messages, should_print_messages, should_check_updates) =
-            if cli.files == vec![PathBuf::from("-")] {
-                let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
-                let path = Path::new(&filename);
-                (
-                    run_once_stdin(&settings, path, cli.fix)?,
-                    !cli.silent && !cli.fix,
-                    false,
-                )
-            } else {
-                (
-                    run_once(&cli.files, &settings, !cli.no_cache, cli.fix)?,
-                    !cli.silent,
-                    !cli.quiet,
-                )
-            };
-        if should_print_messages {
+        let is_stdin = cli.files == vec![PathBuf::from("-")];
+
+        // Generate lint violations.
+        let messages = if is_stdin {
+            let filename = cli.stdin_filename.unwrap_or_else(|| "-".to_string());
+            let path = Path::new(&filename);
+            run_once_stdin(&settings, path, cli.fix)?
+        } else {
+            run_once(&cli.files, &settings, !cli.no_cache, cli.fix)?
+        };
+
+        // Always try to print violations (the printer itself may suppress output),
+        // unless we're writing fixes via stdin (in which case, the transformed
+        // source code goes to stdout).
+        if !(is_stdin && cli.fix) {
             printer.write_once(&messages)?;
         }
 
+        // Check for updates if we're in a non-silent log level.
         #[cfg(feature = "update-informer")]
-        if should_check_updates {
+        if !is_stdin && log_level >= LogLevel::Default {
             check_for_updates();
         }
 

src/printer.rs

@@ -5,6 +5,7 @@ use rustpython_parser::ast::Location;
 use serde::Serialize;
 
 use crate::checks::{CheckCode, CheckKind};
+use crate::logging::LogLevel;
 use crate::message::Message;
 use crate::tell_user;
 
@@ -25,17 +26,27 @@ struct ExpandedMessage<'a> {
     filename: &'a String,
 }
 
-pub struct Printer {
-    format: SerializationFormat,
-    verbose: bool,
+pub struct Printer<'a> {
+    format: &'a SerializationFormat,
+    log_level: &'a LogLevel,
 }
 
-impl Printer {
-    pub fn new(format: SerializationFormat, verbose: bool) -> Self {
-        Self { format, verbose }
+impl<'a> Printer<'a> {
+    pub fn new(format: &'a SerializationFormat, log_level: &'a LogLevel) -> Self {
+        Self { format, log_level }
     }
 
-    pub fn write_once(&mut self, messages: &[Message]) -> Result<()> {
+    pub fn write_to_user(&self, message: &str) {
+        if self.log_level >= &LogLevel::Default {
+            tell_user!("{}", message);
+        }
+    }
+
+    pub fn write_once(&self, messages: &[Message]) -> Result<()> {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return Ok(());
+        }
+
         let (fixed, outstanding): (Vec<&Message>, Vec<&Message>) =
             messages.iter().partition(|message| message.fixed);
         let num_fixable = outstanding
@@ -64,22 +75,26 @@ impl Printer {
                 )
             }
             SerializationFormat::Text => {
-                if !fixed.is_empty() {
-                    println!(
-                        "Found {} error(s) ({} fixed).",
-                        outstanding.len(),
-                        fixed.len()
-                    )
-                } else if !outstanding.is_empty() || self.verbose {
-                    println!("Found {} error(s).", outstanding.len())
+                if self.log_level >= &LogLevel::Default {
+                    if !fixed.is_empty() {
+                        println!(
+                            "Found {} error(s) ({} fixed).",
+                            outstanding.len(),
+                            fixed.len()
+                        )
+                    } else if !outstanding.is_empty() {
+                        println!("Found {} error(s).", outstanding.len())
+                    }
                 }
 
                 for message in outstanding {
                     println!("{}", message)
                 }
 
-                if num_fixable > 0 {
-                    println!("{num_fixable} potentially fixable with the --fix option.")
+                if self.log_level >= &LogLevel::Default {
+                    if num_fixable > 0 {
+                        println!("{num_fixable} potentially fixable with the --fix option.")
+                    }
                 }
             }
         }
@@ -87,14 +102,22 @@ impl Printer {
         Ok(())
     }
 
-    pub fn write_continuously(&mut self, messages: &[Message]) -> Result<()> {
-        tell_user!(
-            "Found {} error(s). Watching for file changes.",
-            messages.len(),
-        );
+    pub fn write_continuously(&self, messages: &[Message]) -> Result<()> {
+        if matches!(self.log_level, LogLevel::Silent) {
+            return Ok(());
+        }
+
+        if self.log_level >= &LogLevel::Default {
+            tell_user!(
+                "Found {} error(s). Watching for file changes.",
+                messages.len(),
+            );
+        }
 
         if !messages.is_empty() {
-            println!();
+            if self.log_level >= &LogLevel::Default {
+                println!();
+            }
             for message in messages {
                 println!("{}", message)
             }
@@ -103,7 +126,7 @@ impl Printer {
         Ok(())
     }
 
-    pub fn clear_screen(&mut self) -> Result<()> {
+    pub fn clear_screen(&self) -> Result<()> {
         #[cfg(not(target_family = "wasm"))]
         clearscreen::clear()?;
         Ok(())

src/pyflakes/fixes.rs

@@ -20,13 +20,13 @@ pub fn remove_unused_imports(
     let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
         body
     } else {
-        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
+        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple"));
     };
     let body = if let Some(SmallStatement::Import(body)) = body.body.first_mut() {
         body
     } else {
         return Err(anyhow::anyhow!(
-            "Expected node to be: SmallStatement::ImportFrom."
+            "Expected node to be: SmallStatement::ImportFrom"
         ));
     };
     let aliases = &mut body.names;
@@ -77,20 +77,20 @@ pub fn remove_unused_import_froms(
     let body = if let Some(Statement::Simple(body)) = tree.body.first_mut() {
         body
     } else {
-        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple."));
+        return Err(anyhow::anyhow!("Expected node to be: Statement::Simple"));
     };
     let body = if let Some(SmallStatement::ImportFrom(body)) = body.body.first_mut() {
         body
     } else {
         return Err(anyhow::anyhow!(
-            "Expected node to be: SmallStatement::ImportFrom."
+            "Expected node to be: SmallStatement::ImportFrom"
         ));
     };
 
     let aliases = if let ImportNames::Aliases(aliases) = &mut body.names {
         aliases
     } else {
-        return Err(anyhow::anyhow!("Expected node to be: Aliases."));
+        return Err(anyhow::anyhow!("Expected node to be: Aliases"));
     };
 
     // Preserve the trailing comma (or not) from the last entry.

src/settings/types.rs

@@ -12,6 +12,7 @@ use crate::checks_gen::CheckCodePrefix;
 use crate::fs;
 
 #[derive(Clone, Debug, PartialOrd, PartialEq, Eq, Serialize, Deserialize, Hash)]
+#[serde(rename_all = "lowercase")]
 pub enum PythonVersion {
     Py33,
     Py34,

src/snapshots/ruff__linter__tests__C406_C406.py.snap

@@ -10,7 +10,16 @@ expression: checks
   end_location:
     row: 1
     column: 19
-  fix: ~
+  fix:
+    patch:
+      content: "{1: 2}"
+      location:
+        row: 1
+        column: 5
+      end_location:
+        row: 1
+        column: 19
+    applied: false
 - kind:
     UnnecessaryLiteralDict: tuple
   location:
@@ -19,7 +28,16 @@ expression: checks
   end_location:
     row: 2
     column: 20
-  fix: ~
+  fix:
+    patch:
+      content: "{1: 2,}"
+      location:
+        row: 2
+        column: 5
+      end_location:
+        row: 2
+        column: 20
+    applied: false
 - kind:
     UnnecessaryLiteralDict: list
   location:
@@ -28,7 +46,16 @@ expression: checks
   end_location:
     row: 3
     column: 13
-  fix: ~
+  fix:
+    patch:
+      content: "{}"
+      location:
+        row: 3
+        column: 5
+      end_location:
+        row: 3
+        column: 13
+    applied: false
 - kind:
     UnnecessaryLiteralDict: tuple
   location:
@@ -37,5 +64,14 @@ expression: checks
   end_location:
     row: 4
     column: 13
-  fix: ~
+  fix:
+    patch:
+      content: "{}"
+      location:
+        row: 4
+        column: 5
+      end_location:
+        row: 4
+        column: 13
+    applied: false
 

src/snapshots/ruff__linter__tests__C408_C408.py.snap

@@ -64,5 +64,14 @@ expression: checks
   end_location:
     row: 4
     column: 14
-  fix: ~
+  fix:
+    patch:
+      content: "{\"a\": 1}"
+      location:
+        row: 4
+        column: 5
+      end_location:
+        row: 4
+        column: 14
+    applied: false
 

src/snapshots/ruff__linter__tests__C416_C416.py.snap

@@ -10,7 +10,16 @@ expression: checks
   end_location:
     row: 2
     column: 14
-  fix: ~
+  fix:
+    patch:
+      content: list(x)
+      location:
+        row: 2
+        column: 0
+      end_location:
+        row: 2
+        column: 14
+    applied: false
 - kind:
     UnnecessaryComprehension: set
   location:
@@ -19,5 +28,14 @@ expression: checks
   end_location:
     row: 3
     column: 14
-  fix: ~
+  fix:
+    patch:
+      content: set(x)
+      location:
+        row: 3
+        column: 0
+      end_location:
+        row: 3
+        column: 14
+    applied: false