Treat Literal["xyz"] as iterable

The extra condition that excluded LiteralType was introduced in #14827
I see no particular reason to have an instance check at all

I was looking at this because of this comment from Emma
#15511 (comment)
Previously we errored with `"Literal['xy']" object is not iterable`
which is of course totally false

Now I issue the same error as in the str case, but restrict to cases
where the unpack length does not match

Author: hauntsaninja

mypy/checker.py

@@ -4117,7 +4117,18 @@ def check_multi_assignment(
             )
         else:
             if isinstance(rvalue_type, Instance) and rvalue_type.type.fullname == "builtins.str":
+                if rvalue_type.last_known_value is None or (
+                    isinstance(rvalue_type.last_known_value, str)
+                    and len(rvalue_type.last_known_value) != len(lvalues)
+                ):
+                    self.msg.unpacking_strings_disallowed(context)
+            if (
+                isinstance(rvalue_type, LiteralType)
+                and isinstance(rvalue_type.value, str)
+                and len(lvalues) != len(rvalue_type.value)
+            ):
                 self.msg.unpacking_strings_disallowed(context)
+
             self.check_multi_assignment_from_iterable(
                 lvalues, rvalue_type, context, infer_lvalue_type
             )
@@ -4363,9 +4374,7 @@ def check_multi_assignment_from_iterable(
         infer_lvalue_type: bool = True,
     ) -> None:
         rvalue_type = get_proper_type(rvalue_type)
-        if self.type_is_iterable(rvalue_type) and isinstance(
-            rvalue_type, (Instance, CallableType, TypeType, Overloaded)
-        ):
+        if self.type_is_iterable(rvalue_type):
             item_type = self.iterable_item_type(rvalue_type, context)
             for lv in lvalues:
                 if isinstance(lv, StarExpr):
@@ -7803,9 +7812,7 @@ def note(
             return
         self.msg.note(msg, context, offset=offset, code=code)
 
-    def iterable_item_type(
-        self, it: Instance | CallableType | TypeType | Overloaded, context: Context
-    ) -> Type:
+    def iterable_item_type(self, it: ProperType, context: Context) -> Type:
         if isinstance(it, Instance):
             iterable = map_instance_to_supertype(it, self.lookup_typeinfo("typing.Iterable"))
             item_type = iterable.args[0]

test-data/unit/check-expressions.test

@@ -2505,3 +2505,24 @@ a2, b2 = s # E: Unpacking a string is disallowed
 reveal_type(a2)  # N: Revealed type is "builtins.str"
 reveal_type(b2)  # N: Revealed type is "builtins.str"
 [builtins fixtures/primitives.pyi]
+
+[case testStringLiteralUnpacking]
+from typing import Literal, Final
+
+def takes_literal(xy: Literal["xy"]):
+    x, y = xy
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+    reveal_type(y)  # N: Revealed type is "builtins.str"
+
+    x, y, z = xy  # E: Unpacking a string is disallowed
+    reveal_type(z)  # N: Revealed type is "builtins.str"
+
+def last_known_value() -> None:
+    xy: Final = "xy"
+    x, y = xy
+    reveal_type(x)  # N: Revealed type is "builtins.str"
+    reveal_type(y)  # N: Revealed type is "builtins.str"
+
+    x, y, z = xy
+    reveal_type(z)  # N: Revealed type is "builtins.str"
+[builtins fixtures/primitives.pyi]