diff --git a/mypy/checker.py b/mypy/checker.py index 065758cd2be9..088c9995a9e2 100644 --- a/mypy/checker.py +++ b/mypy/checker.py @@ -190,6 +190,7 @@ NoneType, Overloaded, PartialType, + PlaceholderType, ProperType, StarType, TupleType, @@ -338,8 +339,6 @@ class TypeChecker(NodeVisitor[None], CheckerPluginInterface): # Used for collecting inferred attribute types so that they can be checked # for consistency. inferred_attribute_types: dict[Var, Type] | None = None - # Don't infer partial None types if we are processing assignment from Union - no_partial_types: bool = False # The set of all dependencies (suppressed or not) that this module accesses, either # directly or indirectly. @@ -3375,7 +3374,6 @@ def check_multi_assignment( context: Context, infer_lvalue_type: bool = True, rv_type: Type | None = None, - undefined_rvalue: bool = False, ) -> None: """Check the assignment of one rvalue to a number of lvalues.""" @@ -3386,12 +3384,6 @@ def check_multi_assignment( if isinstance(rvalue_type, TypeVarLikeType): rvalue_type = get_proper_type(rvalue_type.upper_bound) - if isinstance(rvalue_type, UnionType): - # If this is an Optional type in non-strict Optional code, unwrap it. - relevant_items = rvalue_type.relevant_items() - if len(relevant_items) == 1: - rvalue_type = get_proper_type(relevant_items[0]) - if isinstance(rvalue_type, AnyType): for lv in lvalues: if isinstance(lv, StarExpr): @@ -3402,7 +3394,7 @@ def check_multi_assignment( self.check_assignment(lv, temp_node, infer_lvalue_type) elif isinstance(rvalue_type, TupleType): self.check_multi_assignment_from_tuple( - lvalues, rvalue, rvalue_type, context, undefined_rvalue, infer_lvalue_type + lvalues, rvalue, rvalue_type, context, infer_lvalue_type ) elif isinstance(rvalue_type, UnionType): self.check_multi_assignment_from_union( @@ -3430,58 +3422,86 @@ def check_multi_assignment_from_union( x, y = t reveal_type(x) # Union[int, str] - The idea in this case is to process the assignment for every item of the union. - Important note: the types are collected in two places, 'union_types' contains - inferred types for first assignments, 'assignments' contains the narrowed types - for binder. + The idea is to convert unions of tuples or other iterables to tuples of (simplified) + unions and then simply apply `check_multi_assignment_from_tuple`. """ - self.no_partial_types = True - transposed: tuple[list[Type], ...] = tuple([] for _ in self.flatten_lvalues(lvalues)) - # Notify binder that we want to defer bindings and instead collect types. - with self.binder.accumulate_type_assignments() as assignments: - for item in rvalue_type.items: - # Type check the assignment separately for each union item and collect - # the inferred lvalue types for each union item. - self.check_multi_assignment( - lvalues, - rvalue, - context, - infer_lvalue_type=infer_lvalue_type, - rv_type=item, - undefined_rvalue=True, - ) - for t, lv in zip(transposed, self.flatten_lvalues(lvalues)): - # We can access _type_maps directly since temporary type maps are - # only created within expressions. - t.append(self._type_maps[0].pop(lv, AnyType(TypeOfAny.special_form))) - union_types = tuple(make_simplified_union(col) for col in transposed) - for expr, items in assignments.items(): - # Bind a union of types collected in 'assignments' to every expression. - if isinstance(expr, StarExpr): - expr = expr.expr - - # TODO: See todo in binder.py, ConditionalTypeBinder.assign_type - # It's unclear why the 'declared_type' param is sometimes 'None' - clean_items: list[tuple[Type, Type]] = [] - for type, declared_type in items: - assert declared_type is not None - clean_items.append((type, declared_type)) - - types, declared_types = zip(*clean_items) - self.binder.assign_type( - expr, - make_simplified_union(list(types)), - make_simplified_union(list(declared_types)), - False, + # if `rvalue_type` is Optional type in non-strict Optional code, unwap it: + relevant_items = rvalue_type.relevant_items() + if len(relevant_items) == 1: + self.check_multi_assignment( + lvalues, rvalue, context, infer_lvalue_type, relevant_items[0] ) - for union, lv in zip(union_types, self.flatten_lvalues(lvalues)): - # Properly store the inferred types. - _1, _2, inferred = self.check_lvalue(lv) - if inferred: - self.set_inferred_type(inferred, lv, union) + return + + # union to tuple conversion: + star_idx = next((i for i, lv in enumerate(lvalues) if isinstance(lv, StarExpr)), None) + + def handle_star_index(orig_types: list[Type]) -> list[Type]: + if star_idx is not None: + orig_types[star_idx] = self.named_generic_type( + "builtins.list", [orig_types[star_idx]] + ) + return orig_types + + nmb_subitems = len(lvalues) + items: list[list[Type]] = [] + for idx, item in enumerate(rvalue_type.items): + item = get_proper_type(item) + if isinstance(item, TupleType): + delta = len(item.items) - nmb_subitems + if star_idx is None: + if delta != 0: # a, b = x, y, z or a, b, c = x, y + self.msg.wrong_number_values_to_unpack( + len(item.items), nmb_subitems, context + ) + return + items.append(item.items.copy()) # a, b = x, y + else: + if delta < -1: # a, b, c, *d = x, y + self.msg.wrong_number_values_to_unpack( + len(item.items), nmb_subitems - 1, context + ) + return + if delta == -1: # a, b, *c = x, y + items.append(item.items.copy()) + # to be removed after transposing: + items[-1].insert(star_idx, PlaceholderType("temp", [], -1)) + elif delta == 0: # a, b, *c = x, y, z + items.append(handle_star_index(item.items.copy())) + else: # a, *b = x, y, z + union = make_simplified_union(item.items[star_idx : star_idx + delta + 1]) + subitems = ( + item.items[:star_idx] + [union] + item.items[star_idx + delta + 1 :] + ) + items.append(handle_star_index(subitems)) else: - self.store_type(lv, union) - self.no_partial_types = False + if isinstance(item, AnyType): + items.append(handle_star_index(nmb_subitems * [cast(Type, item)])) + elif isinstance(item, Instance) and (item.type.fullname == "builtins.str"): + self.msg.unpacking_strings_disallowed(context) + return + elif isinstance(item, Instance) and self.type_is_iterable(item): + items.append(handle_star_index(nmb_subitems * [self.iterable_item_type(item)])) + else: + self.msg.type_not_iterable(item, context) + return + items_transposed = zip(*items) + items_cleared = [] + for subitems_ in items_transposed: + subitems = [] + for item in subitems_: + item = get_proper_type(item) + if not isinstance(item, PlaceholderType): + subitems.append(item) + items_cleared.append(subitems) + tupletype = TupleType( + [make_simplified_union(subitems) for subitems in items_cleared], + fallback=self.named_type("builtins.tuple"), + ) + self.check_multi_assignment_from_tuple( + lvalues, rvalue, tupletype, context, infer_lvalue_type, False + ) + return def flatten_lvalues(self, lvalues: list[Expression]) -> list[Expression]: res: list[Expression] = [] @@ -3500,8 +3520,8 @@ def check_multi_assignment_from_tuple( rvalue: Expression, rvalue_type: TupleType, context: Context, - undefined_rvalue: bool, infer_lvalue_type: bool = True, + convert_star_rvalue_type: bool = True, ) -> None: if self.check_rvalue_count_in_assignment(lvalues, len(rvalue_type.items), context): star_index = next( @@ -3512,34 +3532,6 @@ def check_multi_assignment_from_tuple( star_lv = cast(StarExpr, lvalues[star_index]) if star_index != len(lvalues) else None right_lvs = lvalues[star_index + 1 :] - if not undefined_rvalue: - # Infer rvalue again, now in the correct type context. - lvalue_type = self.lvalue_type_for_inference(lvalues, rvalue_type) - reinferred_rvalue_type = get_proper_type( - self.expr_checker.accept(rvalue, lvalue_type) - ) - - if isinstance(reinferred_rvalue_type, UnionType): - # If this is an Optional type in non-strict Optional code, unwrap it. - relevant_items = reinferred_rvalue_type.relevant_items() - if len(relevant_items) == 1: - reinferred_rvalue_type = get_proper_type(relevant_items[0]) - if isinstance(reinferred_rvalue_type, UnionType): - self.check_multi_assignment_from_union( - lvalues, rvalue, reinferred_rvalue_type, context, infer_lvalue_type - ) - return - if isinstance(reinferred_rvalue_type, AnyType): - # We can get Any if the current node is - # deferred. Doing more inference in deferred nodes - # is hard, so give up for now. We can also get - # here if reinferring types above changes the - # inferred return type for an overloaded function - # to be ambiguous. - return - assert isinstance(reinferred_rvalue_type, TupleType) - rvalue_type = reinferred_rvalue_type - left_rv_types, star_rv_types, right_rv_types = self.split_around_star( rvalue_type.items, star_index, len(lvalues) ) @@ -3547,11 +3539,16 @@ def check_multi_assignment_from_tuple( for lv, rv_type in zip(left_lvs, left_rv_types): self.check_assignment(lv, self.temp_node(rv_type, context), infer_lvalue_type) if star_lv: - list_expr = ListExpr( - [self.temp_node(rv_type, context) for rv_type in star_rv_types] - ) - list_expr.set_line(context) - self.check_assignment(star_lv.expr, list_expr, infer_lvalue_type) + if convert_star_rvalue_type: + list_expr = ListExpr( + [self.temp_node(rv_type, context) for rv_type in star_rv_types] + ) + list_expr.set_line(context) + self.check_assignment(star_lv.expr, list_expr, infer_lvalue_type) + else: + self.check_assignment( + star_lv.expr, self.temp_node(star_rv_types[0], context), infer_lvalue_type + ) for lv, rv_type in zip(right_lvs, right_rv_types): self.check_assignment(lv, self.temp_node(rv_type, context), infer_lvalue_type) @@ -3702,10 +3699,7 @@ def infer_variable_type( """Infer the type of initialized variables from initializer type.""" if isinstance(init_type, DeletedType): self.msg.deleted_as_rvalue(init_type, context) - elif ( - not is_valid_inferred_type(init_type, is_lvalue_final=name.is_final) - and not self.no_partial_types - ): + elif not is_valid_inferred_type(init_type, is_lvalue_final=name.is_final): # We cannot use the type of the initialization expression for full type # inference (it's not specific enough), but we might be able to give # partial type which will be made more specific later. A partial type diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test index f80f93eb2615..266de52f0583 100644 --- a/test-data/unit/check-inference-context.test +++ b/test-data/unit/check-inference-context.test @@ -168,9 +168,8 @@ if int(): ab, ao = f(b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") if int(): ao, ab = f(b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") - if int(): - ao, ao = f(b) + ao, ao = f(b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") if int(): ab, ab = f(b) if int(): @@ -199,11 +198,10 @@ if int(): ao, ab, ab, ab = h(b, b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") if int(): ab, ab, ao, ab = h(b, b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") - if int(): - ao, ab, ab = f(b, b) + ao, ab, ab = f(b, b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") if int(): - ab, ab, ao = g(b, b) + ab, ab, ao = g(b, b) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]") if int(): ab, ab, ab, ab = h(b, b) diff --git a/test-data/unit/check-inference.test b/test-data/unit/check-inference.test index 45a833e5210c..8e997d6bf9eb 100644 --- a/test-data/unit/check-inference.test +++ b/test-data/unit/check-inference.test @@ -1919,6 +1919,54 @@ class C: a = 42 [out] +[case testDefinePartiallyInitialisedVariableDuringTupleUnpacking] +# flags: --strict-optional +from typing import Tuple, Union + +t1: Union[Tuple[None], Tuple[str]] +x1 = None +x1, = t1 +reveal_type(x1) # N: Revealed type is "Union[None, builtins.str]" + +t2: Union[Tuple[str], Tuple[None]] +x2 = None +x2, = t2 +reveal_type(x2) # N: Revealed type is "Union[builtins.str, None]" + +t3: Union[Tuple[int], Tuple[str]] +x3 = None +x3, = t3 +reveal_type(x3) # N: Revealed type is "Union[builtins.int, builtins.str]" + +def f() -> Union[ + Tuple[None, None, None, int, int, int, int, int, int], + Tuple[None, None, None, int, int, int, str, str, str] + ]: ... +a1 = None +b1 = None +c1 = None +a2: object +b2: object +c2: object +a1, a2, a3, b1, b2, b3, c1, c2, c3 = f() +reveal_type(a1) # N: Revealed type is "None" +reveal_type(a2) # N: Revealed type is "None" +reveal_type(a3) # N: Revealed type is "None" +reveal_type(b1) # N: Revealed type is "builtins.int" +reveal_type(b2) # N: Revealed type is "builtins.int" +reveal_type(b3) # N: Revealed type is "builtins.int" +reveal_type(c1) # N: Revealed type is "Union[builtins.int, builtins.str]" +reveal_type(c2) # N: Revealed type is "Union[builtins.int, builtins.str]" +reveal_type(c3) # N: Revealed type is "Union[builtins.int, builtins.str]" + +tt: Tuple[Union[Tuple[None], Tuple[str], Tuple[int]]] +z = None +z, = tt[0] +reveal_type(z) # N: Revealed type is "Union[None, builtins.str, builtins.int]" + +[builtins fixtures/tuple.pyi] + + -- More partial type errors -- ------------------------ diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test index cdb27d10fe0c..155fd270ed4b 100644 --- a/test-data/unit/check-tuples.test +++ b/test-data/unit/check-tuples.test @@ -1054,7 +1054,8 @@ def g(x: T) -> Tuple[T, T]: return (x, x) z = 1 -x, y = g(z) # E: Argument 1 to "g" has incompatible type "int"; expected "Tuple[B1, B2]" +x, y = g(z) # E: Incompatible types in assignment (expression has type "int", variable has type "Tuple[A, ...]") \ + # E: Incompatible types in assignment (expression has type "int", variable has type "Tuple[Union[B1, C], Union[B2, C]]") [builtins fixtures/tuple.pyi] [out] diff --git a/test-data/unit/check-unions.test b/test-data/unit/check-unions.test index 4c4fbc32ec3f..a6cfb6b12511 100644 --- a/test-data/unit/check-unions.test +++ b/test-data/unit/check-unions.test @@ -619,7 +619,7 @@ from typing import Union, Tuple a: Union[Tuple[int, int], Tuple[int, float]] a1: object a2: int -(a1, a2) = a # E: Incompatible types in assignment (expression has type "float", variable has type "int") +(a1, a2) = a # E: Incompatible types in assignment (expression has type "Union[int, float]", variable has type "int") b: Union[Tuple[float, int], Tuple[int, int]] b1: object @@ -721,10 +721,11 @@ reveal_type(d) # N: Revealed type is "builtins.list[builtins.int]" from typing import Union bad: Union[int, str] -x, y = bad # E: "int" object is not iterable \ - # E: Unpacking a string is disallowed -reveal_type(x) # N: Revealed type is "Any" -reveal_type(y) # N: Revealed type is "Any" +x, y = bad # E: "int" object is not iterable +reveal_type(x) # E: Cannot determine type of "x" \ + # N: Revealed type is "Any" +reveal_type(y) # E: Cannot determine type of "y" \ + # N: Revealed type is "Any" [out] [case testStringDisallowedUnpacking] @@ -746,8 +747,10 @@ from typing import Union, Tuple bad: Union[Tuple[int, int, int], Tuple[str, str, str]] x, y = bad # E: Too many values to unpack (2 expected, 3 provided) -reveal_type(x) # N: Revealed type is "Any" -reveal_type(y) # N: Revealed type is "Any" +reveal_type(x) # E: Cannot determine type of "x" \ + # N: Revealed type is "Any" +reveal_type(y) # E: Cannot determine type of "y" \ + # N: Revealed type is "Any" [builtins fixtures/tuple.pyi] [out] @@ -756,10 +759,14 @@ from typing import Union, Tuple bad: Union[Tuple[int, int, int], Tuple[str, str, str]] x, y, z, w = bad # E: Need more than 3 values to unpack (4 expected) -reveal_type(x) # N: Revealed type is "Any" -reveal_type(y) # N: Revealed type is "Any" -reveal_type(z) # N: Revealed type is "Any" -reveal_type(w) # N: Revealed type is "Any" +reveal_type(x) # E: Cannot determine type of "x" \ + # N: Revealed type is "Any" +reveal_type(y) # E: Cannot determine type of "y" \ + # N: Revealed type is "Any" +reveal_type(z) # E: Cannot determine type of "z" \ + # N: Revealed type is "Any" +reveal_type(w) # E: Cannot determine type of "w" \ + # N: Revealed type is "Any" [builtins fixtures/tuple.pyi] [out] @@ -820,6 +827,125 @@ reveal_type(lst) # N: Revealed type is "Union[builtins.list[builtins.int], built [builtins fixtures/list.pyi] [out] +[case testUnionUnpackingIncludingListPackingSameItemTypes] +from typing import Tuple, Union +t: Union[Tuple[int, int], Tuple[float, float, float], Tuple[str, str, str, str]] + +a1, = t # E: Too many values to unpack (1 expected, 2 provided) +reveal_type(a1) # E: Cannot determine type of "a1" \ + # N: Revealed type is "Any" +*b2, = t +reveal_type(b2) # N: Revealed type is "Union[builtins.list[builtins.int], builtins.list[builtins.float], builtins.list[builtins.str]]" +a1, b2 = t # E: Too many values to unpack (2 expected, 3 provided) +*c2, d2 = t +reveal_type(c2) # N: Revealed type is "Union[builtins.list[builtins.int], builtins.list[builtins.float], builtins.list[builtins.str]]" +reveal_type(d2) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +e2, *h2 = t +reveal_type(e2) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +reveal_type(h2) # N: Revealed type is "Union[builtins.list[builtins.int], builtins.list[builtins.float], builtins.list[builtins.str]]" + +a3, b3, c3 = t # E: Need more than 2 values to unpack (3 expected) + +*e3, f3, g3 = t +reveal_type(e3) # N: Revealed type is "Union[builtins.list[builtins.float], builtins.list[builtins.str]]" +reveal_type(f3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +reveal_type(g3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" + +h3, *i3, j3 = t +reveal_type(h3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +reveal_type(i3) # N: Revealed type is "Union[builtins.list[builtins.float], builtins.list[builtins.str]]" +reveal_type(g3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" + +k3, l3, *m3 = t +reveal_type(k3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +reveal_type(l3) # N: Revealed type is "Union[builtins.int, builtins.float, builtins.str]" +reveal_type(m3) # N: Revealed type is "Union[builtins.list[builtins.float], builtins.list[builtins.str]]" + +a4, b4, c4, d4 = t # E: Need more than 2 values to unpack (4 expected) + +*e4, f4, g4, h4 = t # E: Need more than 2 values to unpack (3 expected) + +[builtins fixtures/tuple.pyi] + +[case testUnionUnpackingIncludingListPackingDifferentItemTypes] +from typing import Tuple, Union + +class A1: ... +class B1: ... +class C1: ... +class D1: ... +class A2: ... +class B2: ... +class C2: ... +class D2: ... + +t: Union[Tuple[A1, B1, C1, D1], Tuple[A2, B2, C2, D2]] + +a1, b1, c1, d1 = t +reveal_type(a1) # N: Revealed type is "Union[__main__.A1, __main__.A2]" +reveal_type(b1) # N: Revealed type is "Union[__main__.B1, __main__.B2]" +reveal_type(c1) # N: Revealed type is "Union[__main__.C1, __main__.C2]" +reveal_type(d1) # N: Revealed type is "Union[__main__.D1, __main__.D2]" + +a2, *bc2, d2 = t +reveal_type(a2) # N: Revealed type is "Union[__main__.A1, __main__.A2]" +reveal_type(bc2) # N: Revealed type is "Union[builtins.list[Union[__main__.B1, __main__.C1]], builtins.list[Union[__main__.B2, __main__.C2]]]" +reveal_type(d2) # N: Revealed type is "Union[__main__.D1, __main__.D2]" + +*abc3, d3 = t +reveal_type(abc3) # N: Revealed type is "Union[builtins.list[Union[__main__.A1, __main__.B1, __main__.C1]], builtins.list[Union[__main__.A2, __main__.B2, __main__.C2]]]" +reveal_type(d3) # N: Revealed type is "Union[__main__.D1, __main__.D2]" + +a4, *bcd4 = t +reveal_type(a4) # N: Revealed type is "Union[__main__.A1, __main__.A2]" +reveal_type(bcd4) # N: Revealed type is "Union[builtins.list[Union[__main__.B1, __main__.C1, __main__.D1]], builtins.list[Union[__main__.B2, __main__.C2, __main__.D2]]]" + +*abcd5, = t +reveal_type(abcd5) # N: Revealed type is "Union[builtins.list[Union[__main__.A1, __main__.B1, __main__.C1, __main__.D1]], builtins.list[Union[__main__.A2, __main__.B2, __main__.C2, __main__.D2]]]" + +[builtins fixtures/tuple.pyi] + +[case testUnionUnpackingIncludingListPackingForVariousItemTypes] +from typing import Any, List, Tuple, Union + +class A: ... +class B: ... +class C: ... +class D: ... + +t1: Union[Tuple[A, B]] +a1, b1, *c1 = t1 # E: Need type annotation for "c1" (hint: "c1: List[] = ...") +reveal_type(a1) # N: Revealed type is "__main__.A" +reveal_type(b1) # N: Revealed type is "__main__.B" +reveal_type(c1) # N: Revealed type is "builtins.list[Any]" + +t2: Union[Tuple[A, B], List[D]] +a2, b2, *c2 = t2 +reveal_type(a2) # N: Revealed type is "Union[__main__.A, __main__.D]" +reveal_type(b2) # N: Revealed type is "Union[__main__.B, __main__.D]" +reveal_type(c2) # N: Revealed type is "builtins.list[__main__.D]" + +t3: Union[Tuple[A, B, C], List[D]] +a3, b3, *c3 = t3 +reveal_type(a3) # N: Revealed type is "Union[__main__.A, __main__.D]" +reveal_type(b3) # N: Revealed type is "Union[__main__.B, __main__.D]" +reveal_type(c3) # N: Revealed type is "Union[builtins.list[__main__.C], builtins.list[__main__.D]]" + +t4: Union[Tuple[A, B, C], List[D], Any] +a4, b4, *c4 = t4 +reveal_type(a4) # N: Revealed type is "Union[__main__.A, __main__.D, Any]" +reveal_type(b4) # N: Revealed type is "Union[__main__.B, __main__.D, Any]" +reveal_type(c4) # N: Revealed type is "Union[builtins.list[__main__.C], builtins.list[__main__.D], builtins.list[Any]]" + +t5: Union[Tuple[A, B, C], str] +a5, b5, *c5 = t5 # E: Unpacking a string is disallowed + +t6: Union[Tuple[A, B, C], D] +a6, b6, *c6 = t6 # E: "D" object is not iterable + +[builtins fixtures/tuple.pyi] + + [case testUnionUnpackingInForTuple] from typing import Union, Tuple, NamedTuple class NTInt(NamedTuple): @@ -977,8 +1103,9 @@ from typing import Dict, Tuple, List, Any a: Any d: Dict[str, Tuple[List[Tuple[str, str]], str]] -x, _ = d.get(a, ([], [])) -reveal_type(x) # N: Revealed type is "Union[builtins.list[Tuple[builtins.str, builtins.str]], builtins.list[]]" +x, _ = d.get(a, ([], [])) # E: Need type annotation for "x" \ + # E: Need type annotation for "_" +reveal_type(x) # N: Revealed type is "Union[builtins.list[Tuple[builtins.str, builtins.str]], builtins.list[Any]]" for y in x: pass [builtins fixtures/dict.pyi] diff --git a/test-data/unit/check-varargs.test b/test-data/unit/check-varargs.test index 00ac7df320d2..52c8af004d54 100644 --- a/test-data/unit/check-varargs.test +++ b/test-data/unit/check-varargs.test @@ -531,19 +531,19 @@ T = TypeVar('T') a, b, aa = None, None, None # type: (A, B, List[A]) if int(): - a, b = f(*aa) # E: Argument 1 to "f" has incompatible type "*List[A]"; expected "B" + a, b = f(*aa) # E: Incompatible types in assignment (expression has type "A", variable has type "B") if int(): - b, b = f(*aa) # E: Argument 1 to "f" has incompatible type "*List[A]"; expected "B" + b, b = f(*aa) # E: Incompatible types in assignment (expression has type "A", variable has type "B") if int(): - a, a = f(b, *aa) # E: Argument 1 to "f" has incompatible type "B"; expected "A" + a, a = f(b, *aa) # E: Incompatible types in assignment (expression has type "B", variable has type "A") if int(): - b, b = f(b, *aa) # E: Argument 2 to "f" has incompatible type "*List[A]"; expected "B" + b, b = f(b, *aa) # E: Incompatible types in assignment (expression has type "A", variable has type "B") if int(): - b, b = f(b, b, *aa) # E: Argument 3 to "f" has incompatible type "*List[A]"; expected "B" + b, b = f(b, b, *aa) # E: Incompatible types in assignment (expression has type "object", variable has type "B") if int(): - a, b = f(a, *a) # E: List or tuple expected as variadic arguments + a, b = f(a, *a) # E: List or tuple expected as variadic arguments if int(): - a, b = f(*a) # E: List or tuple expected as variadic arguments + a, b = f(*a) # E: List or tuple expected as variadic arguments if int(): a, a = f(*aa) @@ -566,13 +566,13 @@ T = TypeVar('T') a, b = None, None # type: (A, B) if int(): - a, a = f(*(a, b)) # E: Argument 1 to "f" has incompatible type "*Tuple[A, B]"; expected "A" + a, a = f(*(a, b)) # E: Incompatible types in assignment (expression has type "B", variable has type "A") if int(): - b, b = f(a, *(b,)) # E: Argument 1 to "f" has incompatible type "A"; expected "B" + b, b = f(a, *(b,)) # E: Incompatible types in assignment (expression has type "A", variable has type "B") if int(): - a, a = f(*(a, b)) # E: Argument 1 to "f" has incompatible type "*Tuple[A, B]"; expected "A" + a, a = f(*(a, b)) # E: Incompatible types in assignment (expression has type "B", variable has type "A") if int(): - b, b = f(a, *(b,)) # E: Argument 1 to "f" has incompatible type "A"; expected "B" + b, b = f(a, *(b,)) # E: Incompatible types in assignment (expression has type "A", variable has type "B") if int(): a, b = f(*(a, b, b)) # E: Too many arguments for "f" if int(): @@ -606,16 +606,18 @@ if int(): aa, a = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[]", variable has type "A") if int(): ab, aa = G().f(*[a]) \ + # E: Incompatible types in assignment (expression has type "List[A]", variable has type "List[B]") \ # E: Incompatible types in assignment (expression has type "List[]", variable has type "List[A]") \ # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \ - # N: Consider using "Sequence" instead, which is covariant \ - # E: Argument 1 to "f" of "G" has incompatible type "*List[A]"; expected "B" + # N: Consider using "Sequence" instead, which is covariant if int(): ao, ao = G().f(*[a]) \ - # E: Incompatible types in assignment (expression has type "List[]", variable has type "List[object]") \ + # E: Incompatible types in assignment (expression has type "List[A]", variable has type "List[object]") \ # N: "List" is invariant -- see https://mypy.readthedocs.io/en/stable/common_issues.html#variance \ - # N: Consider using "Sequence" instead, which is covariant + # N: Consider using "Sequence" instead, which is covariant \ + # E: Incompatible types in assignment (expression has type "List[]", variable has type "List[object]") + if int(): aa, aa = G().f(*[a]) \ # E: Incompatible types in assignment (expression has type "List[]", variable has type "List[A]") \