diff --git a/crates/ruff_linter/src/rules/flake8_pyi/rules/duplicate_literal_member.rs b/crates/ruff_linter/src/rules/flake8_pyi/rules/duplicate_literal_member.rs
index b68f441f54a69..4c3a8001dc6d6 100644
--- a/crates/ruff_linter/src/rules/flake8_pyi/rules/duplicate_literal_member.rs
+++ b/crates/ruff_linter/src/rules/flake8_pyi/rules/duplicate_literal_member.rs
@@ -12,19 +12,19 @@ use ruff_text_size::Ranged;
 use crate::checkers::ast::Checker;
 
 /// ## What it does
-/// Checks for duplicate literal members.
+/// Checks for duplicate members in a `typing.Literal[]` slice.
 ///
 /// ## Why is this bad?
 /// Duplicate literal members are redundant and should be removed.
 ///
 /// ## Example
 /// ```python
-/// foo: Literal[True, False, True]
+/// foo: Literal["a", "b", "a"]
 /// ```
 ///
 /// Use instead:
 /// ```python
-/// foo: Literal[True, False]
+/// foo: Literal["a", "b"]
 /// ```
 ///
 /// ## References
@@ -52,13 +52,12 @@ pub(crate) fn duplicate_literal_member<'a>(checker: &mut Checker, expr: &'a Expr
     let mut check_for_duplicate_members = |expr: &'a Expr, _: &'a Expr| {
         // If we've already seen this literal member, raise a violation.
         if !seen_nodes.insert(expr.into()) {
-            let diagnostic = Diagnostic::new(
+            diagnostics.push(Diagnostic::new(
                 DuplicateLiteralMember {
                     duplicate_name: checker.generator().expr(expr),
                 },
                 expr.range(),
-            );
-            diagnostics.push(diagnostic);
+            ));
         }
     };
 
diff --git a/crates/ruff_python_semantic/src/analyze/typing.rs b/crates/ruff_python_semantic/src/analyze/typing.rs
index 258fd3349f20a..08875307d0c98 100644
--- a/crates/ruff_python_semantic/src/analyze/typing.rs
+++ b/crates/ruff_python_semantic/src/analyze/typing.rs
@@ -437,7 +437,7 @@ where
         // Ex) Literal[x, y]
         if let Expr::Subscript(ast::ExprSubscript { value, slice, .. }) = expr {
             if semantic.match_typing_expr(value, "Literal") {
-                match slice.as_ref() {
+                match &**slice {
                     Expr::Tuple(ast::ExprTuple { elts, .. }) => {
                         // Traverse each element of the tuple within the literal recursively to handle cases
                         // such as `Literal[..., Literal[...]]