[pyupgrade]: new rule UP050 (useless-class-metaclass-type)

crates/ruff_linter/resources/test/fixtures/pyupgrade/UP050.py

@@ -0,0 +1,84 @@
+class A:
+    ...
+
+
+class A(metaclass=type):
+    ...
+
+
+class A(
+    metaclass=type
+):
+    ...
+
+
+class A(
+    metaclass=type
+    #
+):
+    ...
+
+
+class A(
+    #
+    metaclass=type
+):
+    ...
+
+
+class A(
+    metaclass=type,
+    #
+):
+    ...
+
+
+class A(
+    #
+    metaclass=type,
+    #
+):
+    ...
+
+
+class B(A, metaclass=type):
+    ...
+
+
+class B(
+    A,
+    metaclass=type,
+):
+    ...
+
+
+class B(
+    A,
+    # comment
+    metaclass=type,
+):
+    ...
+
+
+def foo():
+    class A(metaclass=type):
+        ...
+
+
+class A(
+    metaclass=type  # comment
+    ,
+):
+    ...
+
+
+type = str
+
+class Foo(metaclass=type):
+    ...
+
+
+import builtins
+
+class A(metaclass=builtins.type):
+    ...

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

@@ -439,6 +439,9 @@ pub(crate) fn statement(stmt: &Stmt, checker: &mut Checker) {
             if checker.enabled(Rule::UselessObjectInheritance) {
                 pyupgrade::rules::useless_object_inheritance(checker, class_def);
             }
+            if checker.enabled(Rule::UselessClassMetaclassType) {
+                pyupgrade::rules::useless_class_metaclass_type(checker, class_def);
+            }
             if checker.enabled(Rule::ReplaceStrEnum) {
                 if checker.target_version() >= PythonVersion::PY311 {
                     pyupgrade::rules::replace_str_enum(checker, class_def);

crates/ruff_linter/src/codes.rs

@@ -552,6 +552,7 @@ pub fn code_to_rule(linter: Linter, code: &str) -> Option<(RuleGroup, Rule)> {
         (Pyupgrade, "046") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP695GenericClass),
         (Pyupgrade, "047") => (RuleGroup::Preview, rules::pyupgrade::rules::NonPEP695GenericFunction),
         (Pyupgrade, "049") => (RuleGroup::Preview, rules::pyupgrade::rules::PrivateTypeParameter),
+        (Pyupgrade, "050") => (RuleGroup::Preview, rules::pyupgrade::rules::UselessClassMetaclassType),
 
         // pydocstyle
         (Pydocstyle, "100") => (RuleGroup::Stable, rules::pydocstyle::rules::UndocumentedPublicModule),

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

@@ -111,6 +111,7 @@ mod tests {
     #[test_case(Rule::NonPEP695GenericFunction, Path::new("UP047.py"))]
     #[test_case(Rule::PrivateTypeParameter, Path::new("UP049_0.py"))]
     #[test_case(Rule::PrivateTypeParameter, Path::new("UP049_1.py"))]
+    #[test_case(Rule::UselessClassMetaclassType, Path::new("UP050.py"))]
     fn rules(rule_code: Rule, path: &Path) -> Result<()> {
         let snapshot = path.to_string_lossy().to_string();
         let diagnostics = test_path(

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

@@ -37,6 +37,7 @@ pub(crate) use unpacked_list_comprehension::*;
 pub(crate) use use_pep585_annotation::*;
 pub(crate) use use_pep604_annotation::*;
 pub(crate) use use_pep604_isinstance::*;
+pub(crate) use useless_class_metaclass_type::*;
 pub(crate) use useless_metaclass_type::*;
 pub(crate) use useless_object_inheritance::*;
 pub(crate) use yield_in_for_loop::*;
@@ -80,6 +81,7 @@ mod unpacked_list_comprehension;
 mod use_pep585_annotation;
 mod use_pep604_annotation;
 mod use_pep604_isinstance;
+mod useless_class_metaclass_type;
 mod useless_metaclass_type;
 mod useless_object_inheritance;
 mod yield_in_for_loop;

crates/ruff_linter/src/rules/pyupgrade/rules/useless_class_metaclass_type.rs

@@ -0,0 +1,79 @@
+use crate::checkers::ast::Checker;
+use crate::fix::edits::{Parentheses, remove_argument};
+use ruff_diagnostics::{Diagnostic, Fix, FixAvailability, Violation};
+use ruff_macros::{ViolationMetadata, derive_message_formats};
+use ruff_python_ast::StmtClassDef;
+use ruff_text_size::Ranged;
+
+/// ## What it does
+/// Checks for `metaclass=type` in class definitions.
+///
+/// ## Why is this bad?
+/// Since Python 3, the default metaclass is `type`, so specifying it explicitly is redundant.
+///
+/// Even though `__prepare__` is not required, the default metaclass (`type`) implements it,
+/// for the convenience of subclasses calling it via `super()`.
+/// ## Example
+///
+/// ```python
+/// class Foo(metaclass=type): ...
+/// ```
+///
+/// Use instead:
+///
+/// ```python
+/// class Foo: ...
+/// ```
+///
+/// ## References
+/// - [PEP 3115 – Metaclasses in Python 3000](https://peps.python.org/pep-3115/)
+#[derive(ViolationMetadata)]
+pub(crate) struct UselessClassMetaclassType {
+    name: String,
+}
+
+impl Violation for UselessClassMetaclassType {
+    const FIX_AVAILABILITY: FixAvailability = FixAvailability::Sometimes;
+
+    #[derive_message_formats]
+    fn message(&self) -> String {
+        let UselessClassMetaclassType { name } = self;
+        format!("Class `{name}` uses `metaclass=type`, which is redundant")
+    }
+
+    fn fix_title(&self) -> Option<String> {
+        Some("Remove `metaclass=type`".to_string())
+    }
+}
+
+/// UP050
+pub(crate) fn useless_class_metaclass_type(checker: &Checker, class_def: &StmtClassDef) {
+    let Some(arguments) = class_def.arguments.as_deref() else {
+        return;
+    };
+
+    for keyword in &arguments.keywords {
+        if let (Some("metaclass"), expr) = (keyword.arg.as_deref(), &keyword.value) {
+            if checker.semantic().match_builtin_expr(expr, "type") {
+                let mut diagnostic = Diagnostic::new(
+                    UselessClassMetaclassType {
+                        name: class_def.name.to_string(),
+                    },
+                    keyword.range(),
+                );
+
+                diagnostic.try_set_fix(|| {
+                    remove_argument(
+                        keyword,
+                        arguments,
+                        Parentheses::Remove,
+                        checker.locator().contents(),
+                    )
+                    .map(Fix::safe_edit)
+                });
+
+                checker.report_diagnostic(diagnostic);
+            }
+        }
+    }
+}