Move conditions around

Author: charliermarsh

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

@@ -198,28 +198,31 @@ pub(crate) fn native_literals(
             checker.diagnostics.push(diagnostic);
         }
         Some(arg) => {
-            let (literal_expr, unary) = if let Some(literal_expr) = arg.as_literal_expr() {
-                (literal_expr, false)
+            let literal_expr = if let Some(literal_expr) = arg.as_literal_expr() {
+                // Skip implicit concatenated strings.
+                if literal_expr.is_implicit_concatenated() {
+                    return;
+                } else {
+                    literal_expr
+                }
             } else if let Expr::UnaryOp(ast::ExprUnaryOp {
                 op: UnaryOp::UAdd | UnaryOp::USub,
                 operand,
                 ..
             }) = arg
             {
-                if let Some(literal_expr) = operand.as_literal_expr() {
-                    (literal_expr, true)
+                if let Some(literal_expr) = operand
+                    .as_literal_expr()
+                    .filter(|expr| matches!(expr, LiteralExpressionRef::NumberLiteral(_)))
+                {
+                    literal_expr
                 } else {
                     return;
                 }
             } else {
                 return;
             };
 
-            // Skip implicit string concatenations.
-            if literal_expr.is_implicit_concatenated() {
-                return;
-            }
-
             let Ok(arg_literal_type) = LiteralType::try_from(literal_expr) else {
                 return;
             };
@@ -228,12 +231,6 @@ pub(crate) fn native_literals(
                 return;
             }
 
-            if unary {
-                if !matches!(literal_type, LiteralType::Int | LiteralType::Float) {
-                    return;
-                }
-            }
-
             let arg_code = checker.locator().slice(arg);
 
             // Attribute access on an integer requires the integer to be parenthesized to disambiguate from a float