Only infer LiteralType if one of thhe operands is a Literal

Author: cdce8p

mypy/checkexpr.py

@@ -3585,19 +3585,19 @@ def visit_op_expr(self, e: OpExpr) -> Type:
 
     def literal_value_from_expr(
         self, expr: Expression, typ: Type | None = None
-    ) -> tuple[list[str | int], str] | None:
+    ) -> tuple[list[str | int], str, bool] | None:
         if isinstance(expr, StrExpr):
-            return [expr.value], "builtins.str"
+            return [expr.value], "builtins.str", False
         if isinstance(expr, IntExpr):
-            return [expr.value], "builtins.int"
+            return [expr.value], "builtins.int", False
         if isinstance(expr, BytesExpr):
-            return [expr.value], "builtins.bytes"
+            return [expr.value], "builtins.bytes", False
 
         typ = typ or self.accept(expr)
         ptype = get_proper_type(typ)
 
         if isinstance(ptype, LiteralType) and not isinstance(ptype.value, (bool, float)):
-            return [ptype.value], ptype.fallback.type.fullname
+            return [ptype.value], ptype.fallback.type.fullname, True
 
         if isinstance(ptype, UnionType):
             fallback: str | None = None
@@ -3613,15 +3613,19 @@ def literal_value_from_expr(
                 values.append(pitem.value)
             else:
                 assert fallback is not None
-                return values, fallback
+                return values, fallback, True
         return None
 
     def literal_expression_addition(self, e: OpExpr, left_type: Type) -> Type | None:
         """Check if literal values can be combined with addition."""
         assert e.op == "+"
         if not (lvalue := self.literal_value_from_expr(e.left, left_type)):
             return None
-        if not (rvalue := self.literal_value_from_expr(e.right)) or lvalue[1] != rvalue[1]:
+        if (
+            not (rvalue := self.literal_value_from_expr(e.right))
+            or lvalue[1] != rvalue[1]  # different fallback
+            or lvalue[2] + rvalue[2] == 0  # no LiteralType
+        ):
             return None
 
         values: list[int | str] = sorted(

test-data/unit/check-literal.test

@@ -2999,6 +2999,7 @@ b: bytes
 
 misc_union: Literal["a", 1]
 
+reveal_type("a" + "b")  # N: Revealed type is "builtins.str"
 reveal_type(str_a + str_b)  # N: Revealed type is "Literal['ab']"
 reveal_type(str_a + "b")    # N: Revealed type is "Literal['ab']"
 reveal_type("a" + str_b)    # N: Revealed type is "Literal['ab']"
@@ -3012,6 +3013,7 @@ reveal_type(s + str_a)  # N: Revealed type is "builtins.str"
 reveal_type(str_union_1 + s)  # N: Revealed type is "builtins.str"
 reveal_type(s + str_union_1)  # N: Revealed type is "builtins.str"
 
+reveal_type(1 + 2)  # N: Revealed type is "builtins.int"
 reveal_type(int_1 + int_2)  # N: Revealed type is "Literal[3]"
 reveal_type(int_1 + 1)      # N: Revealed type is "Literal[2]"
 reveal_type(1 + int_1)      # N: Revealed type is "Literal[2]"
@@ -3025,6 +3027,7 @@ reveal_type(i + int_1)  # N: Revealed type is "builtins.int"
 reveal_type(int_union_1 + i)  # N: Revealed type is "builtins.int"
 reveal_type(i + int_union_1)  # N: Revealed type is "builtins.int"
 
+reveal_type(b"a" + b"b")  # N: Revealed type is "builtins.bytes"
 reveal_type(bytes_a + bytes_b)  # N: Revealed type is "Literal[b'ab']"
 reveal_type(bytes_a + b"b")    # N: Revealed type is "Literal[b'ab']"
 reveal_type(b"a" + bytes_b)    # N: Revealed type is "Literal[b'ab']"