[ruff] Fix false positive for re.split with empty string pattern (RUF055) (#23634)

## Summary

Fixes #23629.

`re.split("", s)` is flagged by RUF055 and auto-fixed to `s.split("")`,
but `str.split("")` raises `ValueError: empty separator` while
`re.split("", s)` succeeds (returning `["", "a", "b", "c", ""]`). The
same applies to bytes (`rb""`).

This adds a guard to skip the diagnostic when the separator pattern is
an empty string or bytes literal specifically for `re.split` calls.
Other `re` functions (`sub`, `match`, `search`, `fullmatch`) are not
affected — their `str` equivalents all handle empty strings
equivalently.

## Test Plan

Added test cases for empty string and bytes patterns in `RUF055_0.py`
and `RUF055_3.py`. Verified that no diagnostics are emitted for these
cases and all existing RUF055 snapshot tests continue to pass:

```
cargo test -p ruff_linter -- "preview_rules::rule_unnecessaryregularexpression"
test result: ok. 4 passed; 0 failed; 0 ignored
```

Author: bxff

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

@@ -98,3 +98,8 @@ def dashrepl(matchobj):
 re.sub(r'abc', "", s)
 re.sub(r"""abc""", "", s)
 re.sub(r'''abc''', "", s)
+
+# Empty pattern: re.split("", s) should not be flagged because
+# str.split("") raises ValueError while re.split("", s) succeeds
+re.split("", s)
+re.split(r"", s)

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

@@ -21,4 +21,7 @@
 re.match(rb"ab[c]", b_src)
 re.search(rb"ab[c]", b_src)
 re.fullmatch(rb"ab[c]", b_src)
-re.split(rb"ab[c]", b_src) 
+re.split(rb"ab[c]", b_src)
+
+# Empty pattern: re.split(rb"", b_src) should not be flagged
+re.split(rb"", b_src)

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

@@ -118,6 +118,12 @@ pub(crate) fn unnecessary_regular_expression(checker: &Checker, call: &ExprCall)
         return;
     }
 
+    // `str.split("")` raises `ValueError: empty separator` while `re.split("", s)` succeeds,
+    // so skip the diagnostic for `re.split` with an empty pattern.
+    if matches!(re_func.kind, ReFuncKind::Split) && literal.is_empty() {
+        return;
+    }
+
     // Now we know the pattern is a string literal with no metacharacters, so
     // we can proceed with the str method replacement.
     let new_expr = re_func.replacement();
@@ -362,6 +368,15 @@ enum Literal<'a> {
     Bytes(&'a ExprBytesLiteral),
 }
 
+impl Literal<'_> {
+    fn is_empty(&self) -> bool {
+        match self {
+            Literal::Str(str_lit) => str_lit.value.is_empty(),
+            Literal::Bytes(bytes_lit) => bytes_lit.value.is_empty(),
+        }
+    }
+}
+
 /// Try to resolve `name` to either a string or bytes literal in `semantic`.
 fn resolve_literal<'a>(name: &'a Expr, semantic: &'a SemanticModel) -> Option<Literal<'a>> {
     if let Some(str_lit) = resolve_string_literal(name, semantic) {

crates/ruff_linter/src/rules/ruff/snapshots/ruff_linter__rules__ruff__tests__preview__RUF055_RUF055_0.py.snap

@@ -243,6 +243,7 @@ help: Replace with `s.replace(r'abc', "")`
 98  + s.replace(r'abc', "")
 99  | re.sub(r"""abc""", "", s)
 100 | re.sub(r'''abc''', "", s)
+101 | 
 
 RUF055 [*] Plain string pattern passed to `re` function
    --> RUF055_0.py:99:1
@@ -260,6 +261,8 @@ help: Replace with `s.replace(r"""abc""", "")`
     - re.sub(r"""abc""", "", s)
 99  + s.replace(r"""abc""", "")
 100 | re.sub(r'''abc''', "", s)
+101 | 
+102 | # Empty pattern: re.split("", s) should not be flagged because
 
 RUF055 [*] Plain string pattern passed to `re` function
    --> RUF055_0.py:100:1
@@ -268,10 +271,15 @@ RUF055 [*] Plain string pattern passed to `re` function
  99 | re.sub(r"""abc""", "", s)
 100 | re.sub(r'''abc''', "", s)
     | ^^^^^^^^^^^^^^^^^^^^^^^^^
+101 |
+102 | # Empty pattern: re.split("", s) should not be flagged because
     |
 help: Replace with `s.replace(r'''abc''', "")`
 97  | # these double as tests for preserving raw string quoting style
 98  | re.sub(r'abc', "", s)
 99  | re.sub(r"""abc""", "", s)
     - re.sub(r'''abc''', "", s)
 100 + s.replace(r'''abc''', "")
+101 | 
+102 | # Empty pattern: re.split("", s) should not be flagged because
+103 | # str.split("") raises ValueError while re.split("", s) succeeds

crates/ty/docs/rules.md

@@ -78,8 +78,7 @@ class Answer(Enum):
 
     non_member_1: int
 
-    # TODO: this could be considered an error:
-    non_member_1: str = "some value"
+    non_member_1: str = "some value"  # error: [invalid-enum-member-annotation]
 
 # revealed: tuple[Literal["YES"], Literal["NO"]]
 reveal_type(enum_members(Answer))
@@ -100,6 +99,103 @@ class Answer(Enum):
 reveal_type(enum_members(Answer))
 ```
 
+### Annotated enum members
+
+The [typing spec] states that enum members should not have explicit type annotations. Type checkers
+should report an error for annotated enum members because the annotation is misleading — the actual
+type of an enum member is the enum class itself, not the annotated type.
+
+```py
+from enum import Enum
+
+class Pet(Enum):
+    CAT = 1
+    DOG: int = 2  # error: [invalid-enum-member-annotation] "Type annotation on enum member `DOG` is not allowed"
+    BIRD: str = "bird"  # error: [invalid-enum-member-annotation]
+```
+
+Bare `Final` annotations are allowed (they don't specify a type):
+
+```py
+from enum import Enum
+from typing import Final
+
+class Pet(Enum):
+    CAT: Final = 1  # OK
+    DOG: Final = 2  # OK
+```
+
+But `Final` with a type argument is not allowed:
+
+```py
+from enum import Enum
+from typing import Final
+
+class Pet(Enum):
+    CAT: Final[int] = 1  # error: [invalid-enum-member-annotation]
+    DOG: Final[str] = "woof"  # error: [invalid-enum-member-annotation]
+```
+
+`enum.member` used as value wrapper is the standard way to declare members explicitly:
+
+```toml
+[environment]
+python-version = "3.11"
+```
+
+```py
+from enum import Enum, member
+
+class Pet(Enum):
+    CAT = member(1)  # OK
+```
+
+Dunder and private names are not enum members, so they don't trigger the diagnostic:
+
+```py
+from enum import Enum
+
+class Pet(Enum):
+    CAT = 1
+    __private: int = 2  # OK: dunder/private names are never members
+    __module__: str = "my_module"  # OK
+```
+
+Pure declarations (annotations without values) are non-members and are fine:
+
+```py
+from enum import Enum
+
+class Pet(Enum):
+    CAT = 1
+    species: str  # OK: no value, so this is a non-member declaration
+```
+
+The check also works for subclasses of `Enum`:
+
+```py
+from enum import IntEnum, StrEnum
+
+class Status(IntEnum):
+    OK: int = 200  # error: [invalid-enum-member-annotation]
+    NOT_FOUND = 404  # OK
+
+class Color(StrEnum):
+    RED: str = "red"  # error: [invalid-enum-member-annotation]
+    GREEN = "green"  # OK
+```
+
+Special sunder names like `_value_` and `_ignore_` are not flagged:
+
+```py
+from enum import Enum
+
+class Pet(Enum):
+    _value_: int = 0  # OK: `_value_` is a special enum name
+    _ignore_: str = "TEMP"  # OK: `_ignore_` is a special enum name
+    CAT = 1
+```
+
 ### Declared `_value_` annotation
 
 If a `_value_` annotation is defined on an `Enum` class, all enum member values must be compatible
@@ -814,7 +910,7 @@ class Answer(Enum):
 
     def is_yes(self) -> bool:
         return self == Answer.YES
-    constant: int = 1
+    constant: int = 1  # error: [invalid-enum-member-annotation]
 
 reveal_type(Answer.YES.is_yes())  # revealed: bool
 reveal_type(Answer.YES.constant)  # revealed: int
@@ -1353,3 +1449,4 @@ class MyEnum[T](MyEnumBase):
 - Documentation: <https://docs.python.org/3/library/enum.html>
 
 [class-private names]: https://docs.python.org/3/reference/lexical_analysis.html#reserved-classes-of-identifiers
+[typing spec]: https://typing.python.org/en/latest/spec/enums.html#enum-members

crates/ty_python_semantic/resources/mdtest/enums.md

@@ -83,6 +83,7 @@ pub(crate) fn register_lints(registry: &mut LintRegistryBuilder) {
     registry.register_lint(&INVALID_CONTEXT_MANAGER);
     registry.register_lint(&INVALID_DECLARATION);
     registry.register_lint(&INVALID_EXCEPTION_CAUGHT);
+    registry.register_lint(&INVALID_ENUM_MEMBER_ANNOTATION);
     registry.register_lint(&INVALID_GENERIC_ENUM);
     registry.register_lint(&INVALID_GENERIC_CLASS);
     registry.register_lint(&INVALID_LEGACY_TYPE_VARIABLE);
@@ -1193,6 +1194,49 @@ declare_lint! {
     }
 }
 
+declare_lint! {
+    /// ## What it does
+    /// Checks for enum members that have explicit type annotations.
+    ///
+    /// ## Why is this bad?
+    /// The [typing spec] states that type checkers should infer a literal type
+    /// for all enum members. An explicit type annotation on an enum member is
+    /// misleading because the annotated type will be incorrect — the actual
+    /// runtime type is the enum class itself, not the annotated type.
+    ///
+    /// In CPython's `enum` module, annotated assignments with values are still
+    /// treated as members at runtime, but the annotation is meaningless and
+    /// will confuse readers of the code.
+    ///
+    /// ## Examples
+    /// ```python
+    /// from enum import Enum
+    ///
+    /// class Pet(Enum):
+    ///     CAT = 1       # OK
+    ///     DOG: int = 2  # Error: enum members should not be annotated
+    /// ```
+    ///
+    /// Use instead:
+    /// ```python
+    /// from enum import Enum
+    ///
+    /// class Pet(Enum):
+    ///     CAT = 1
+    ///     DOG = 2
+    /// ```
+    ///
+    /// ## References
+    /// - [Typing spec: Enum members](https://typing.python.org/en/latest/spec/enums.html#enum-members)
+    ///
+    /// [typing spec]: https://typing.python.org/en/latest/spec/enums.html#enum-members
+    pub(crate) static INVALID_ENUM_MEMBER_ANNOTATION = {
+        summary: "detects type annotations on enum members",
+        status: LintStatus::stable("0.0.16"),
+        default_level: Level::Error,
+    }
+}
+
 declare_lint! {
     /// ## What it does
     /// Checks for enum classes that are also generic.

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -74,18 +74,18 @@ use crate::types::diagnostic::{
     DATACLASS_FIELD_ORDER, DUPLICATE_BASE, DUPLICATE_KW_ONLY, FINAL_ON_NON_METHOD,
     FINAL_WITHOUT_VALUE, INCONSISTENT_MRO, INEFFECTIVE_FINAL, INVALID_ARGUMENT_TYPE,
     INVALID_ASSIGNMENT, INVALID_ATTRIBUTE_ACCESS, INVALID_BASE, INVALID_DATACLASS,
-    INVALID_DECLARATION, INVALID_GENERIC_CLASS, INVALID_GENERIC_ENUM, INVALID_KEY,
-    INVALID_LEGACY_POSITIONAL_PARAMETER, INVALID_LEGACY_TYPE_VARIABLE, INVALID_METACLASS,
-    INVALID_NAMED_TUPLE, INVALID_NEWTYPE, INVALID_OVERLOAD, INVALID_PARAMETER_DEFAULT,
-    INVALID_PARAMSPEC, INVALID_PROTOCOL, INVALID_TYPE_ALIAS_TYPE, INVALID_TYPE_ARGUMENTS,
-    INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL, INVALID_TYPE_GUARD_DEFINITION,
-    INVALID_TYPE_VARIABLE_BOUND, INVALID_TYPE_VARIABLE_CONSTRAINTS, INVALID_TYPE_VARIABLE_DEFAULT,
-    INVALID_TYPED_DICT_HEADER, INVALID_TYPED_DICT_STATEMENT, IncompatibleBases, MISSING_ARGUMENT,
-    NO_MATCHING_OVERLOAD, PARAMETER_ALREADY_ASSIGNED, POSSIBLY_MISSING_ATTRIBUTE,
-    POSSIBLY_MISSING_IMPLICIT_CALL, POSSIBLY_MISSING_IMPORT, SUBCLASS_OF_FINAL_CLASS,
-    TOO_MANY_POSITIONAL_ARGUMENTS, TypedDictDeleteErrorKind, UNDEFINED_REVEAL, UNKNOWN_ARGUMENT,
-    UNRESOLVED_ATTRIBUTE, UNRESOLVED_GLOBAL, UNRESOLVED_IMPORT, UNRESOLVED_REFERENCE,
-    UNSUPPORTED_DYNAMIC_BASE, UNSUPPORTED_OPERATOR, USELESS_OVERLOAD_BODY,
+    INVALID_DECLARATION, INVALID_ENUM_MEMBER_ANNOTATION, INVALID_GENERIC_CLASS,
+    INVALID_GENERIC_ENUM, INVALID_KEY, INVALID_LEGACY_POSITIONAL_PARAMETER,
+    INVALID_LEGACY_TYPE_VARIABLE, INVALID_METACLASS, INVALID_NAMED_TUPLE, INVALID_NEWTYPE,
+    INVALID_OVERLOAD, INVALID_PARAMETER_DEFAULT, INVALID_PARAMSPEC, INVALID_PROTOCOL,
+    INVALID_TYPE_ALIAS_TYPE, INVALID_TYPE_ARGUMENTS, INVALID_TYPE_FORM, INVALID_TYPE_GUARD_CALL,
+    INVALID_TYPE_GUARD_DEFINITION, INVALID_TYPE_VARIABLE_BOUND, INVALID_TYPE_VARIABLE_CONSTRAINTS,
+    INVALID_TYPE_VARIABLE_DEFAULT, INVALID_TYPED_DICT_HEADER, INVALID_TYPED_DICT_STATEMENT,
+    IncompatibleBases, MISSING_ARGUMENT, NO_MATCHING_OVERLOAD, PARAMETER_ALREADY_ASSIGNED,
+    POSSIBLY_MISSING_ATTRIBUTE, POSSIBLY_MISSING_IMPLICIT_CALL, POSSIBLY_MISSING_IMPORT,
+    SUBCLASS_OF_FINAL_CLASS, TOO_MANY_POSITIONAL_ARGUMENTS, TypedDictDeleteErrorKind,
+    UNDEFINED_REVEAL, UNKNOWN_ARGUMENT, UNRESOLVED_ATTRIBUTE, UNRESOLVED_GLOBAL, UNRESOLVED_IMPORT,
+    UNRESOLVED_REFERENCE, UNSUPPORTED_DYNAMIC_BASE, UNSUPPORTED_OPERATOR, USELESS_OVERLOAD_BODY,
     hint_if_stdlib_attribute_exists_on_other_versions,
     hint_if_stdlib_submodule_exists_on_other_versions, report_attempted_protocol_instantiation,
     report_bad_dunder_set_call, report_bad_frozen_dataclass_inheritance,
@@ -9635,6 +9635,43 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     &DeclaredAndInferredType::AreTheSame(TypeAndQualifiers::declared(inferred_ty)),
                 );
             } else {
+                // Check for annotated enum members. The typing spec states that enum
+                // members should not have explicit type annotations.
+                if let Some(name_expr) = target.as_name_expr()
+                    && !name_expr.id.starts_with("__")
+                    && !matches!(name_expr.id.as_str(), "_ignore_" | "_value_" | "_name_")
+                    // Not bare Final (bare Final is allowed on enum members)
+                    && !(declared.qualifiers.contains(TypeQualifiers::FINAL)
+                        && matches!(declared.inner_type(), Type::Dynamic(DynamicType::Unknown)))
+                    // Not enum.member annotation
+                    && !matches!(
+                        declared.inner_type(),
+                        Type::NominalInstance(instance)
+                            if instance.has_known_class(self.db(), KnownClass::Member)
+                    )
+                    // Value type would be an enum member at runtime (exclude callables,
+                    // functions, and descriptors which are never members)
+                    && !matches!(inferred_ty, Type::Callable(_) | Type::FunctionLiteral(_))
+                {
+                    let current_scope_id = self.scope().file_scope_id(self.db());
+                    let current_scope = self.index.scope(current_scope_id);
+                    if current_scope.kind() == ScopeKind::Class
+                        && let Some(class) =
+                            nearest_enclosing_class(self.db(), self.index, self.scope())
+                        && is_enum_class_by_inheritance(self.db(), class)
+                    {
+                        if let Some(builder) = self
+                            .context
+                            .report_lint(&INVALID_ENUM_MEMBER_ANNOTATION, annotation)
+                        {
+                            builder.into_diagnostic(format_args!(
+                                "Type annotation on enum member `{}` is not allowed",
+                                &name_expr.id
+                            ));
+                        }
+                    }
+                }
+
                 self.add_declaration_with_binding(
                     target.into(),
                     definition,