Force list expression to infer Union type of member types.

Author: ay0503

mypy/checkexpr.py

@@ -5017,15 +5017,22 @@ def fast_container_type(
         return ct
 
     def check_lst_expr(self, e: ListExpr | SetExpr | TupleExpr, fullname: str, tag: str) -> Type:
-        # fast path
+        # Fast path
         t = self.fast_container_type(e, fullname)
         if t:
             return t
+        if isinstance(e, ListExpr):
+            item_types = [self.accept(item) for item in e.items]
+            # Empty list, default to Any
+            if not item_types:
+                item_type = AnyType(TypeOfAny.from_empty_collection)
+            else:
+                # Attempt to infer a common supertype
+                item_type = self.infer_item_type(item_types)
+            return self.chk.named_generic_type(fullname, [item_type])
 
-        # Translate into type checking a generic function call.
-        # Used for list and set expressions, as well as for tuples
-        # containing star expressions that don't refer to a
-        # Tuple. (Note: "lst" stands for list-set-tuple. :-)
+        # For SetExpr and TupleExpr, use existing logic
+        # Translate into type checking a generic function call
         tv = TypeVarType(
             "T",
             "T",
@@ -5051,6 +5058,21 @@ def check_lst_expr(self, e: ListExpr | SetExpr | TupleExpr, fullname: str, tag:
         )[0]
         return remove_instance_last_known_values(out)
 
+    def infer_item_type(self, item_types: List[Type]) -> Type:
+        """Infer the item type for a list based on its elements."""
+        joined_type = self.chk.join_types(*item_types)
+        proper_joined = get_proper_type(joined_type)
+        if (
+            isinstance(proper_joined, Instance)
+            and proper_joined.type.fullname == "builtins.object"
+            and len(set(map(type, item_types))) > 1
+        ):
+            # No common supertype other than 'object', so use a Union of the item types
+            return UnionType.make_simplified_union(item_types)
+        else:
+            # Use the common supertype
+            return joined_type
+
     def tuple_context_matches(self, expr: TupleExpr, ctx: TupleType) -> bool:
         ctx_unpack_index = find_unpack_in_list(ctx.items)
         if ctx_unpack_index is None: