diff --git a/mypy/checker.py b/mypy/checker.py index 4db6e905c256..c3015bb3ba34 100644 --- a/mypy/checker.py +++ b/mypy/checker.py @@ -1681,7 +1681,7 @@ def visit_class_def(self, defn: ClassDef) -> None: continue dec = self.expr_checker.accept(decorator) - temp = self.temp_node(sig) + temp = self.temp_node(sig, context=decorator) fullname = None if isinstance(decorator, RefExpr): fullname = decorator.fullname @@ -2794,15 +2794,20 @@ def check_member_assignment(self, instance_type: Type, attribute_type: Type, # For this we use the rvalue as type context. self.msg.disable_errors() _, inferred_dunder_set_type = self.expr_checker.check_call( - dunder_set_type, [TempNode(instance_type), rvalue], - [nodes.ARG_POS, nodes.ARG_POS], context) + dunder_set_type, + [TempNode(instance_type, context=context), rvalue], + [nodes.ARG_POS, nodes.ARG_POS], + context) self.msg.enable_errors() # And now we type check the call second time, to show errors related # to wrong arguments count, etc. self.expr_checker.check_call( - dunder_set_type, [TempNode(instance_type), TempNode(AnyType(TypeOfAny.special_form))], - [nodes.ARG_POS, nodes.ARG_POS], context) + dunder_set_type, + [TempNode(instance_type, context=context), + TempNode(AnyType(TypeOfAny.special_form), context=context)], + [nodes.ARG_POS, nodes.ARG_POS], + context) # should be handled by get_method above assert isinstance(inferred_dunder_set_type, CallableType) # type: ignore @@ -3305,7 +3310,7 @@ def visit_decorator(self, e: Decorator) -> None: self.fail(message_registry.MULTIPLE_OVERLOADS_REQUIRED, e) continue dec = self.expr_checker.accept(d) - temp = self.temp_node(sig) + temp = self.temp_node(sig, context=e) fullname = None if isinstance(d, RefExpr): fullname = d.fullname @@ -4039,10 +4044,7 @@ def find_partial_types_in_all_scopes( def temp_node(self, t: Type, context: Optional[Context] = None) -> TempNode: """Create a temporary node with the given, fixed type.""" - temp = TempNode(t) - if context: - temp.set_line(context.get_line()) - return temp + return TempNode(t, context=context) def fail(self, msg: str, context: Context, *, code: Optional[ErrorCode] = None) -> None: """Produce an error message.""" diff --git a/mypy/checkexpr.py b/mypy/checkexpr.py index af4540eda05c..3da1882318a7 100644 --- a/mypy/checkexpr.py +++ b/mypy/checkexpr.py @@ -64,7 +64,16 @@ # Type of callback user for checking individual function arguments. See # check_args() below for details. -ArgChecker = Callable[[Type, Type, int, Type, int, int, CallableType, Context, MessageBuilder], +ArgChecker = Callable[[Type, + Type, + int, + Type, + int, + int, + CallableType, + Context, + Context, + MessageBuilder], None] # Maximum nesting level for math union in overloads, setting this to large values @@ -842,7 +851,7 @@ def check_callable_call(self, self.check_argument_count(callee, arg_types, arg_kinds, arg_names, formal_to_actual, context, self.msg) - self.check_argument_types(arg_types, arg_kinds, callee, formal_to_actual, context, + self.check_argument_types(arg_types, arg_kinds, args, callee, formal_to_actual, context, messages=arg_messages) if (callee.is_type_obj() and (len(arg_types) == 1) @@ -1169,7 +1178,8 @@ def check_argument_count(self, if messages: assert context, "Internal error: messages given without context" elif context is None: - context = TempNode(AnyType(TypeOfAny.special_form)) # Avoid "is None" checks + # Avoid "is None" checks + context = TempNode(AnyType(TypeOfAny.special_form)) # TODO(jukka): We could return as soon as we find an error if messages is None. @@ -1271,6 +1281,7 @@ def check_for_extra_actual_arguments(self, def check_argument_types(self, arg_types: List[Type], arg_kinds: List[int], + args: List[Expression], callee: CallableType, formal_to_actual: List[List[int]], context: Context, @@ -1303,12 +1314,19 @@ def check_argument_types(self, callee.arg_names[i], callee.arg_kinds[i]) check_arg(expanded_actual, actual_type, arg_kinds[actual], callee.arg_types[i], - actual + 1, i + 1, callee, context, messages) + actual + 1, i + 1, callee, args[actual], context, messages) - def check_arg(self, caller_type: Type, original_caller_type: Type, + def check_arg(self, + caller_type: Type, + original_caller_type: Type, caller_kind: int, - callee_type: Type, n: int, m: int, callee: CallableType, - context: Context, messages: MessageBuilder) -> None: + callee_type: Type, + n: int, + m: int, + callee: CallableType, + context: Context, + outer_context: Context, + messages: MessageBuilder) -> None: """Check the type of a single argument in a call.""" caller_type = get_proper_type(caller_type) original_caller_type = get_proper_type(original_caller_type) @@ -1326,8 +1344,13 @@ def check_arg(self, caller_type: Type, original_caller_type: Type, elif not is_subtype(caller_type, callee_type): if self.chk.should_suppress_optional_error([caller_type, callee_type]): return - code = messages.incompatible_argument(n, m, callee, original_caller_type, - caller_kind, context) + code = messages.incompatible_argument(n, + m, + callee, + original_caller_type, + caller_kind, + context=context, + outer_context=outer_context) messages.incompatible_argument_note(original_caller_type, callee_type, context, code=code) @@ -1404,7 +1427,7 @@ def check_overload_call(self, # Neither alternative matches, but we can guess the user probably wants the # second one. erased_targets = self.overload_erased_call_targets(plausible_targets, arg_types, - arg_kinds, arg_names, context) + arg_kinds, arg_names, args, context) # Step 5: We try and infer a second-best alternative if possible. If not, fall back # to using 'Any'. @@ -1569,6 +1592,7 @@ def overload_erased_call_targets(self, arg_types: List[Type], arg_kinds: List[int], arg_names: Optional[Sequence[Optional[str]]], + args: List[Expression], context: Context) -> List[CallableType]: """Returns a list of all targets that match the caller after erasing types. @@ -1576,7 +1600,8 @@ def overload_erased_call_targets(self, """ matches = [] # type: List[CallableType] for typ in plausible_targets: - if self.erased_signature_similarity(arg_types, arg_kinds, arg_names, typ, context): + if self.erased_signature_similarity(arg_types, arg_kinds, arg_names, args, typ, + context): matches.append(typ) return matches @@ -1755,8 +1780,11 @@ def combine_function_signatures(self, types: Sequence[Type]) -> Union[AnyType, C variables=variables, implicit=True) - def erased_signature_similarity(self, arg_types: List[Type], arg_kinds: List[int], + def erased_signature_similarity(self, + arg_types: List[Type], + arg_kinds: List[int], arg_names: Optional[Sequence[Optional[str]]], + args: List[Expression], callee: CallableType, context: Context) -> bool: """Determine whether arguments could match the signature at runtime, after @@ -1772,16 +1800,23 @@ def erased_signature_similarity(self, arg_types: List[Type], arg_kinds: List[int # Too few or many arguments -> no match. return False - def check_arg(caller_type: Type, original_caller_type: Type, caller_kind: int, - callee_type: Type, n: int, m: int, callee: CallableType, - context: Context, messages: MessageBuilder) -> None: + def check_arg(caller_type: Type, + original_ccaller_type: Type, + caller_kind: int, + callee_type: Type, + n: int, + m: int, + callee: CallableType, + context: Context, + outer_context: Context, + messages: MessageBuilder) -> None: if not arg_approximate_similarity(caller_type, callee_type): # No match -- exit early since none of the remaining work can change # the result. raise Finished try: - self.check_argument_types(arg_types, arg_kinds, callee, + self.check_argument_types(arg_types, arg_kinds, args, callee, formal_to_actual, context=context, check_arg=check_arg) return True except Finished: @@ -2429,7 +2464,7 @@ def check_op(self, method: str, base_type: Type, result, inferred = self.check_op_reversible( op_name=method, left_type=left_possible_type, - left_expr=TempNode(left_possible_type), + left_expr=TempNode(left_possible_type, context=context), right_type=right_type, right_expr=arg, context=context, @@ -2456,7 +2491,8 @@ def check_op(self, method: str, base_type: Type, right_variants = [(right_type, arg)] right_type = get_proper_type(right_type) if isinstance(right_type, UnionType): - right_variants = [(item, TempNode(item)) for item in right_type.relevant_items()] + right_variants = [(item, TempNode(item, context=context)) + for item in right_type.relevant_items()] msg = self.msg.clean_copy() msg.disable_count = 0 @@ -2468,7 +2504,7 @@ def check_op(self, method: str, base_type: Type, result, inferred = self.check_op_reversible( op_name=method, left_type=left_possible_type, - left_expr=TempNode(left_possible_type), + left_expr=TempNode(left_possible_type, context=context), right_type=right_possible_type, right_expr=right_expr, context=context, @@ -2481,9 +2517,9 @@ def check_op(self, method: str, base_type: Type, if len(left_variants) >= 2 and len(right_variants) >= 2: self.msg.warn_both_operands_are_from_unions(context) elif len(left_variants) >= 2: - self.msg.warn_operand_was_from_union("Left", base_type, context) + self.msg.warn_operand_was_from_union("Left", base_type, context=right_expr) elif len(right_variants) >= 2: - self.msg.warn_operand_was_from_union("Right", right_type, context) + self.msg.warn_operand_was_from_union("Right", right_type, context=right_expr) # See the comment in 'check_overload_call' for more details on why # we call 'combine_function_signature' instead of just unioning the inferred @@ -2812,10 +2848,10 @@ def visit_reveal_expr(self, expr: RevealExpr) -> Type: assert expr.expr is not None revealed_type = self.accept(expr.expr, type_context=self.type_context[-1]) if not self.chk.current_node_deferred: - self.msg.reveal_type(revealed_type, expr) + self.msg.reveal_type(revealed_type, expr.expr) if not self.chk.in_checked_function(): self.msg.note("'reveal_type' always outputs 'Any' in unchecked functions", - expr) + expr.expr) return revealed_type else: # REVEAL_LOCALS @@ -3064,7 +3100,14 @@ def visit_dict_expr(self, e: DictExpr) -> Type: if key is None: stargs.append(value) else: - args.append(TupleExpr([key, value])) + tup = TupleExpr([key, value]) + if key.line >= 0: + tup.line = key.line + tup.column = key.column + else: + tup.line = value.line + tup.column = value.column + args.append(tup) # Define type variables (used in constructors below). ktdef = TypeVarDef('KT', 'KT', -1, [], self.object_type()) vtdef = TypeVarDef('VT', 'VT', -2, [], self.object_type()) diff --git a/mypy/checkmember.py b/mypy/checkmember.py index 5efda9a70447..2f8b57f11d6c 100644 --- a/mypy/checkmember.py +++ b/mypy/checkmember.py @@ -469,7 +469,8 @@ def analyze_descriptor_access(instance_type: Type, _, inferred_dunder_get_type = chk.expr_checker.check_call( dunder_get_type, - [TempNode(instance_type), TempNode(TypeType.make_normalized(owner_type))], + [TempNode(instance_type, context=context), + TempNode(TypeType.make_normalized(owner_type), context=context)], [ARG_POS, ARG_POS], context) inferred_dunder_get_type = get_proper_type(inferred_dunder_get_type) diff --git a/mypy/fastparse.py b/mypy/fastparse.py index 4de55fc46c59..2deefd6e0840 100644 --- a/mypy/fastparse.py +++ b/mypy/fastparse.py @@ -944,8 +944,8 @@ def visit_UnaryOp(self, n: ast3.UnaryOp) -> UnaryExpr: # Lambda(arguments args, expr body) def visit_Lambda(self, n: ast3.Lambda) -> LambdaExpr: body = ast3.Return(n.body) - body.lineno = n.lineno - body.col_offset = n.col_offset + body.lineno = n.body.lineno + body.col_offset = n.body.col_offset e = LambdaExpr(self.transform_args(n.args, n.lineno), self.as_required_block([body], n.lineno)) @@ -1169,7 +1169,12 @@ def visit_Attribute(self, n: Attribute) -> Union[MemberExpr, SuperExpr]: # Subscript(expr value, slice slice, expr_context ctx) def visit_Subscript(self, n: ast3.Subscript) -> IndexExpr: e = IndexExpr(self.visit(n.value), self.visit(n.slice)) - return self.set_line(e, n) + self.set_line(e, n) + if isinstance(e.index, SliceExpr): + # Slice has no line/column in the raw ast. + e.index.line = e.line + e.index.column = e.column + return e # Starred(expr value, expr_context ctx) def visit_Starred(self, n: Starred) -> StarExpr: diff --git a/mypy/fastparse2.py b/mypy/fastparse2.py index 7dc6261ea858..61dd44228a39 100644 --- a/mypy/fastparse2.py +++ b/mypy/fastparse2.py @@ -834,8 +834,8 @@ def visit_Lambda(self, n: ast27.Lambda) -> LambdaExpr: args, decompose_stmts = self.transform_args(n.args, n.lineno) n_body = ast27.Return(n.body) - n_body.lineno = n.lineno - n_body.col_offset = n.col_offset + n_body.lineno = n.body.lineno + n_body.col_offset = n.body.col_offset body = self.as_required_block([n_body], n.lineno) if decompose_stmts: body.body = decompose_stmts + body.body @@ -1009,7 +1009,12 @@ def visit_Attribute(self, n: Attribute) -> Expression: # Subscript(expr value, slice slice, expr_context ctx) def visit_Subscript(self, n: ast27.Subscript) -> IndexExpr: e = IndexExpr(self.visit(n.value), self.visit(n.slice)) - return self.set_line(e, n) + self.set_line(e, n) + if isinstance(e.index, SliceExpr): + # Slice has no line/column in the raw ast. + e.index.line = e.line + e.index.column = e.column + return e # Name(identifier id, expr_context ctx) def visit_Name(self, n: Name) -> NameExpr: diff --git a/mypy/messages.py b/mypy/messages.py index 8e0d3ba38e0a..7703bf29e32f 100644 --- a/mypy/messages.py +++ b/mypy/messages.py @@ -324,8 +324,14 @@ def untyped_function_call(self, callee: CallableType, context: Context) -> Type: code=codes.NO_UNTYPED_CALL) return AnyType(TypeOfAny.from_error) - def incompatible_argument(self, n: int, m: int, callee: CallableType, arg_type: Type, - arg_kind: int, context: Context) -> Optional[ErrorCode]: + def incompatible_argument(self, + n: int, + m: int, + callee: CallableType, + arg_type: Type, + arg_kind: int, + context: Context, + outer_context: Context) -> Optional[ErrorCode]: """Report an error about an incompatible argument type. The argument type is arg_type, argument number is n and the @@ -456,8 +462,8 @@ def incompatible_argument(self, n: int, m: int, callee: CallableType, arg_type: # For function calls with keyword arguments, display the argument name rather than the # number. arg_label = str(n) - if isinstance(context, CallExpr) and len(context.arg_names) >= n: - arg_name = context.arg_names[n - 1] + if isinstance(outer_context, CallExpr) and len(outer_context.arg_names) >= n: + arg_name = outer_context.arg_names[n - 1] if arg_name is not None: arg_label = '"{}"'.format(arg_name) diff --git a/mypy/nodes.py b/mypy/nodes.py index 79343f4ad212..500069f082c0 100644 --- a/mypy/nodes.py +++ b/mypy/nodes.py @@ -2224,13 +2224,21 @@ class TempNode(Expression): # (e.g. for 'x: int' the rvalue is TempNode(AnyType(TypeOfAny.special_form), no_rhs=True)) no_rhs = False # type: bool - def __init__(self, typ: 'mypy.types.Type', no_rhs: bool = False) -> None: + def __init__(self, + typ: 'mypy.types.Type', + no_rhs: bool = False, + *, + context: Optional[Context] = None) -> None: + """Construct a dummy node; optionally borrow line/column from context object.""" super().__init__() self.type = typ self.no_rhs = no_rhs + if context is not None: + self.line = context.line + self.column = context.column def __repr__(self) -> str: - return 'TempNode(%s)' % str(self.type) + return 'TempNode:%d(%s)' % (self.line, str(self.type)) def accept(self, visitor: ExpressionVisitor[T]) -> T: return visitor.visit_temp_node(self) diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test index c00ffd076a56..938b868eff14 100644 --- a/test-data/unit/check-classes.test +++ b/test-data/unit/check-classes.test @@ -1377,14 +1377,13 @@ class D: def __get__(self, inst: Base, own: Type[Base]) -> str: pass [builtins fixtures/bool.pyi] [out] -main:5: note: Revealed type is 'd.D' main:5: error: Argument 2 to "__get__" of "D" has incompatible type "Type[A]"; expected "Type[Base]" -main:6: note: Revealed type is 'Any' +main:5: note: Revealed type is 'd.D' main:6: error: No overload variant of "__get__" of "D" matches argument types "A", "Type[A]" main:6: note: Possible overload variants: main:6: note: def __get__(self, inst: None, own: Type[Base]) -> D main:6: note: def __get__(self, inst: Base, own: Type[Base]) -> str - +main:6: note: Revealed type is 'Any' [case testAccessingGenericNonDataDescriptor] from typing import TypeVar, Type, Generic, Any @@ -1480,12 +1479,11 @@ class D(Generic[T, V]): def __get__(self, inst: T, own: Type[T]) -> V: pass [builtins fixtures/bool.pyi] [out] -main:5: note: Revealed type is 'Any' main:5: error: No overload variant of "__get__" of "D" matches argument types "None", "Type[A]" main:5: note: Possible overload variants: main:5: note: def __get__(self, inst: None, own: None) -> D[A, int] main:5: note: def __get__(self, inst: A, own: Type[A]) -> int - +main:5: note: Revealed type is 'Any' [case testAccessingNonDataDescriptorSubclass] from typing import Any @@ -4844,8 +4842,9 @@ def f() -> type: return M class C1(six.with_metaclass(M), object): pass # E: Unsupported dynamic base class "six.with_metaclass" class C2(C1, six.with_metaclass(M)): pass # E: Unsupported dynamic base class "six.with_metaclass" class C3(six.with_metaclass(A)): pass # E: Metaclasses not inheriting from 'type' are not supported -@six.add_metaclass(A) # E: Argument 1 to "add_metaclass" has incompatible type "Type[A]"; expected "Type[type]" \ - # E: Metaclasses not inheriting from 'type' are not supported +@six.add_metaclass(A) # E: Metaclasses not inheriting from 'type' are not supported \ + # E: Argument 1 to "add_metaclass" has incompatible type "Type[A]"; expected "Type[type]" + class D3(A): pass class C4(six.with_metaclass(M), metaclass=M): pass # E: Multiple metaclass definitions @six.add_metaclass(M) @@ -4970,8 +4969,8 @@ def decorate_forward_ref() -> Callable[[Type[A]], Type[A]]: @decorate(11) class A: pass -@decorate -class A2: pass # E: Argument 1 to "decorate" has incompatible type "Type[A2]"; expected "int" +@decorate # E: Argument 1 to "decorate" has incompatible type "Type[A2]"; expected "int" +class A2: pass [case testClassDecoratorIncorrect] def not_a_class_decorator(x: int) -> int: ... diff --git a/test-data/unit/check-columns.test b/test-data/unit/check-columns.test index 7dbe55db92e7..fcc37087a61e 100644 --- a/test-data/unit/check-columns.test +++ b/test-data/unit/check-columns.test @@ -22,10 +22,59 @@ class A: pass A().f() A().f(1) -(A().f('')) # E:2: Argument 1 to "f" of "A" has incompatible type "str"; expected "int" -( A().f(1, 1)) # E:3: Argument 2 to "f" of "A" has incompatible type "int"; expected "str" +A().f('') # E:7: Argument 1 to "f" of "A" has incompatible type "str"; expected "int" +A().f(1, 1) # E:10: Argument 2 to "f" of "A" has incompatible type "int"; expected "str" (A().f(1, 'hello', 'hi')) # E:2: Too many arguments for "f" of "A" +[case testColumnsInvalidArgumentType] +# flags: --strict-optional +def f(x: int, y: str) -> None: ... +def g(*x: int) -> None: pass +def h(**x: int) -> None: pass +def ff(x: int) -> None: pass + +class A: + x: str + def __neg__(self) -> str: pass + def __add__(self, other: int) -> str: pass + def __lt__(self, other: int) -> str: pass + +f( + y=0, x=0) # E:4: Argument "y" to "f" has incompatible type "int"; expected "str" +f(x=0, + y=None) # E:6: Argument "y" to "f" has incompatible type "None"; expected "str" +g(1, '', 2) # E:6: Argument 2 to "g" has incompatible type "str"; expected "int" +aaa: str +h(x=1, y=aaa, z=2) # E:10: Argument "y" to "h" has incompatible type "str"; expected "int" +a: A +ff(a.x) # E:4: Argument 1 to "ff" has incompatible type "str"; expected "int" +ff([1]) # E:4: Argument 1 to "ff" has incompatible type "List[int]"; expected "int" +# TODO: Different column in Python 3.8+ +#ff([1 for x in [1]]) # Argument 1 to "ff" has incompatible type "List[int]"; expected "int" +ff({1: 2}) # E:4: Argument 1 to "ff" has incompatible type "Dict[int, int]"; expected "int" +ff(1.1) # E:4: Argument 1 to "ff" has incompatible type "float"; expected "int" +# TODO: Different column in Python 3.8+ +#ff( ( 1, 1)) # Argument 1 to "ff" has incompatible type "Tuple[int, int]"; expected "int" +ff(-a) # E:4: Argument 1 to "ff" has incompatible type "str"; expected "int" +ff(a + 1) # E:4: Argument 1 to "ff" has incompatible type "str"; expected "int" +ff(a < 1) # E:4: Argument 1 to "ff" has incompatible type "str"; expected "int" +ff([''][0]) # E:4: Argument 1 to "ff" has incompatible type "str"; expected "int" + +class B(A): + def f(self) -> None: + ff(super().__neg__()) # E:12: Argument 1 to "ff" has incompatible type "str"; expected "int" +[builtins fixtures/dict.pyi] + +[case testColumnsInvalidArgumentTypeVarArgs] +def f(*x: int) -> None: pass +def g(**x: int) -> None: pass + +a = [''] +f(*a) # E:4: Argument 1 to "f" has incompatible type "*List[str]"; expected "int" +b = {'x': 'y'} +g(**b) # E:5: Argument 1 to "g" has incompatible type "**Dict[str, str]"; expected "int" +[builtins fixtures/dict.pyi] + [case testColumnsMultipleStatementsPerLine] x = 15 y = 'hello' @@ -33,7 +82,7 @@ if int(): x = 2; y = x; y += 1 [out] main:4:12: error: Incompatible types in assignment (expression has type "int", variable has type "str") -main:4:19: error: Unsupported operand types for + ("str" and "int") +main:4:24: error: Unsupported operand types for + ("str" and "int") [case testColumnsSimpleIsinstance] import typing @@ -130,11 +179,11 @@ def f(x, y): pass [case testColumnListOrDictItemHasIncompatibleType] from typing import List, Dict -# TODO: Point to the actual item since a list/dict literal can span many lines -x: List[int] = [ # E:16: List item 0 has incompatible type "str"; expected "int" - 'x'] -y: Dict[int, int] = { # E:21: Dict entry 0 has incompatible type "str": "int"; expected "int": "int" - 'x': 1 +x: List[int] = [ + 'x', # E:5: List item 0 has incompatible type "str"; expected "int" + 1.1] # E:7: List item 1 has incompatible type "float"; expected "int" +y: Dict[int, int] = { + 'x': 1 # E:5: Dict entry 0 has incompatible type "str": "int"; expected "int": "int" } [builtins fixtures/dict.pyi] @@ -144,7 +193,7 @@ x = None [case testColumnInvalidIndexing] from typing import List -([1]['']) # E:2: Invalid index type "str" for "List[int]"; expected type "int" +([1]['']) # E:6: Invalid index type "str" for "List[int]"; expected type "int" (1[1]) # E:2: Value of type "int" is not indexable def f() -> None: 1[1] = 1 # E:5: Unsupported target for indexed assignment @@ -222,7 +271,7 @@ if int(): [case testColumnRevealedType] if int(): - reveal_type(1) # N:5: Revealed type is 'builtins.int' + reveal_type(1) # N:17: Revealed type is 'builtins.int' [case testColumnNonOverlappingEqualityCheck] # flags: --strict-equality @@ -301,7 +350,7 @@ def f(x: T) -> T: g(y=x) # E:5: Unexpected keyword argument "y" for "g" y: List[int, str] # E:8: "list" expects 1 type argument, but 2 given del 1[0] # E:5: "int" has no attribute "__delitem__" - bb: List[int] = [''] # E:21: List item 0 has incompatible type "str"; expected "int" + bb: List[int] = [''] # E:22: List item 0 has incompatible type "str"; expected "int" # XXX: Disabled because the column differs in 3.8 # aa: List[int] = ['' for x in [1]] # :22: List comprehension has incompatible type List[str]; expected List[int] cc = (1).bad # E:11: "int" has no attribute "bad" diff --git a/test-data/unit/check-expressions.test b/test-data/unit/check-expressions.test index 4a15a0778be5..49aba1727d4b 100644 --- a/test-data/unit/check-expressions.test +++ b/test-data/unit/check-expressions.test @@ -1671,8 +1671,8 @@ def f(x: int) -> None: [builtins fixtures/for.pyi] [out] main:1: error: The return type of a generator function should be "Generator" or one of its supertypes -main:2: error: Argument 1 to "f" has incompatible type "str"; expected "int" main:2: error: "f" does not return a value +main:2: error: Argument 1 to "f" has incompatible type "str"; expected "int" [case testYieldExpressionWithNone] from typing import Iterator @@ -1847,8 +1847,8 @@ main:4: note: z: builtins.int [case testUndefinedRevealType] reveal_type(x) [out] -main:1: note: Revealed type is 'Any' main:1: error: Name 'x' is not defined +main:1: note: Revealed type is 'Any' [case testUserDefinedRevealType] def reveal_type(x: int) -> None: pass @@ -1919,8 +1919,8 @@ from typing import Dict, Callable def things() -> int: return 42 -stuff: Dict[int, Callable[[], str]] = { # E: Dict entry 0 has incompatible type "int": "Callable[[], int]"; expected "int": "Callable[[], str]" - 1: things +stuff: Dict[int, Callable[[], str]] = { + 1: things # E: Dict entry 0 has incompatible type "int": "Callable[[], int]"; expected "int": "Callable[[], str]" } [builtins fixtures/dict.pyi] diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test index 4a3829200f65..0441f26cee36 100644 --- a/test-data/unit/check-generics.test +++ b/test-data/unit/check-generics.test @@ -616,8 +616,8 @@ main:15:10: error: "list" expects 1 type argument, but 2 given main:16:19: error: "list" expects 1 type argument, but 2 given main:17:25: error: "Node" expects 2 type arguments, but 1 given main:19:5: error: Bad number of arguments for type alias, expected: 1, given: 2 -main:22:1: note: Revealed type is '__main__.Node[builtins.int, builtins.str]' -main:24:1: note: Revealed type is '__main__.Node[__main__.Node[builtins.int, builtins.int], builtins.list[builtins.int]]' +main:22:13: note: Revealed type is '__main__.Node[builtins.int, builtins.str]' +main:24:13: note: Revealed type is '__main__.Node[__main__.Node[builtins.int, builtins.int], builtins.list[builtins.int]]' main:26:5: error: Type variable "__main__.T" is invalid as target for type alias [case testGenericTypeAliasesForAliases] diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test index 048abc483e57..095c55bb4904 100644 --- a/test-data/unit/check-inference-context.test +++ b/test-data/unit/check-inference-context.test @@ -697,8 +697,9 @@ def f(func: Callable[[T], S], *z: T, r: S = None) -> S: pass f(lambda x: 0 if isinstance(x, B) else 1) # E: Cannot infer type argument 1 of "f" f(lambda x: 0 if isinstance(x, B) else 1, A())() # E: "int" not callable f(lambda x: x if isinstance(x, B) else B(), A(), r=B())() # E: "B" not callable -f( # E: Argument 1 to "f" has incompatible type "Callable[[A], A]"; expected "Callable[[A], B]" - lambda x: B() if isinstance(x, B) else x, # E: Incompatible return value type (got "A", expected "B") +f( + lambda x: # E: Argument 1 to "f" has incompatible type "Callable[[A], A]"; expected "Callable[[A], B]" + B() if isinstance(x, B) else x, # E: Incompatible return value type (got "A", expected "B") A(), r=B()) [builtins fixtures/isinstance.pyi] diff --git a/test-data/unit/check-isinstance.test b/test-data/unit/check-isinstance.test index ca3b2fb176ea..8729b87a297b 100644 --- a/test-data/unit/check-isinstance.test +++ b/test-data/unit/check-isinstance.test @@ -968,8 +968,8 @@ def foo() -> Union[int, str, A]: pass def bar() -> None: x = foo() - x + 1 # E: Unsupported operand types for + ("str" and "int") \ - # E: Unsupported left operand type for + ("A") \ + x + 1 # E: Unsupported left operand type for + ("A") \ + # E: Unsupported operand types for + ("str" and "int") \ # N: Left operand is of type "Union[int, str, A]" if isinstance(x, A): x.a diff --git a/test-data/unit/check-literal.test b/test-data/unit/check-literal.test index 03e93857ec38..56d9feac3fd4 100644 --- a/test-data/unit/check-literal.test +++ b/test-data/unit/check-literal.test @@ -1579,19 +1579,19 @@ reveal_type(func(c)) # N: Revealed type is 'Union[__main__.B, __main__.A]' reveal_type(func(d)) # N: Revealed type is '__main__.B' \ # E: Argument 1 to "func" has incompatible type "Union[Literal[6], Literal[7]]"; expected "Union[Literal[3], Literal[4], Literal[5], Literal[6]]" -reveal_type(func(e)) # N: Revealed type is 'Any' \ - # E: No overload variant of "func" matches argument type "int" \ +reveal_type(func(e)) # E: No overload variant of "func" matches argument type "int" \ # N: Possible overload variants: \ # N: def func(x: Literal[-40]) -> A \ # N: def func(x: Union[Literal[3], Literal[4], Literal[5], Literal[6]]) -> B \ - # N: def func(x: Literal['foo']) -> C + # N: def func(x: Literal['foo']) -> C \ + # N: Revealed type is 'Any' -reveal_type(func(f)) # N: Revealed type is 'Any' \ - # E: No overload variant of "func" matches argument type "Union[Literal[7], Literal['bar']]" \ +reveal_type(func(f)) # E: No overload variant of "func" matches argument type "Union[Literal[7], Literal['bar']]" \ # N: Possible overload variants: \ # N: def func(x: Literal[-40]) -> A \ # N: def func(x: Union[Literal[3], Literal[4], Literal[5], Literal[6]]) -> B \ - # N: def func(x: Literal['foo']) -> C + # N: def func(x: Literal['foo']) -> C \ + # N: Revealed type is 'Any' [out] [case testLiteralInferredInOverloadContextUnionMathOverloadingReturnsBestType] @@ -1941,12 +1941,12 @@ reveal_type(func1) # N: Revealed type is 'def [TLiteral <: Literal[3]] (x: reveal_type(func1(3)) # N: Revealed type is 'Literal[3]' reveal_type(func1(a)) # N: Revealed type is 'Literal[3]' -reveal_type(func1(4)) # N: Revealed type is 'Literal[4]' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" -reveal_type(func1(b)) # N: Revealed type is 'Literal[4]' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" -reveal_type(func1(c)) # N: Revealed type is 'builtins.int*' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "int" +reveal_type(func1(4)) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" \ + # N: Revealed type is 'Literal[4]' +reveal_type(func1(b)) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" \ + # N: Revealed type is 'Literal[4]' +reveal_type(func1(c)) # E: Value of type variable "TLiteral" of "func1" cannot be "int" \ + # N: Revealed type is 'builtins.int*' reveal_type(func2(3)) # N: Revealed type is 'builtins.int*' reveal_type(func2(a)) # N: Revealed type is 'Literal[3]' @@ -1986,21 +1986,20 @@ reveal_type(func1) # N: Revealed type is 'def [TLiteral in (Literal[3], reveal_type(func1(3)) # N: Revealed type is 'Literal[3]' reveal_type(func1(i1)) # N: Revealed type is 'Literal[3]' -reveal_type(func1(4)) # N: Revealed type is 'Literal[4]' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" -reveal_type(func1(i2)) # N: Revealed type is 'Literal[4]' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" -reveal_type(func1(i)) # N: Revealed type is 'builtins.int*' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "int" - +reveal_type(func1(4)) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" \ + # N: Revealed type is 'Literal[4]' +reveal_type(func1(i2)) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal[4]" \ + # N: Revealed type is 'Literal[4]' +reveal_type(func1(i)) # E: Value of type variable "TLiteral" of "func1" cannot be "int" \ + # N: Revealed type is 'builtins.int*' reveal_type(func1("foo")) # N: Revealed type is 'Literal['foo']' reveal_type(func1(s1)) # N: Revealed type is 'Literal['foo']' -reveal_type(func1("bar")) # N: Revealed type is 'Literal['bar']' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal['bar']" -reveal_type(func1(s2)) # N: Revealed type is 'Literal['bar']' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "Literal['bar']" -reveal_type(func1(s)) # N: Revealed type is 'builtins.str*' \ - # E: Value of type variable "TLiteral" of "func1" cannot be "str" +reveal_type(func1("bar")) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal['bar']" \ + # N: Revealed type is 'Literal['bar']' +reveal_type(func1(s2)) # E: Value of type variable "TLiteral" of "func1" cannot be "Literal['bar']" \ + # N: Revealed type is 'Literal['bar']' +reveal_type(func1(s)) # E: Value of type variable "TLiteral" of "func1" cannot be "str" \ + # N: Revealed type is 'builtins.str*' reveal_type(func2(3)) # N: Revealed type is 'builtins.int*' reveal_type(func2(i1)) # N: Revealed type is 'builtins.int*' @@ -2061,8 +2060,8 @@ reveal_type(arr5) # N: Revealed type is 'builtins.list[def (Literal[1]) -> buil # Inspect just only one interesting one lit: Literal[1] -reveal_type(arr2[0](lit)) # N: Revealed type is 'Any' \ - # E: Cannot call function of unknown type +reveal_type(arr2[0](lit)) # E: Cannot call function of unknown type \ + # N: Revealed type is 'Any' T = TypeVar('T') def unify(func: Callable[[T, T], None]) -> T: pass @@ -2092,8 +2091,8 @@ lit: Literal[1] arr = [a, b] reveal_type(arr) # N: Revealed type is 'builtins.list[builtins.function*]' -reveal_type(arr[0](lit)) # N: Revealed type is 'Any' \ - # E: Cannot call function of unknown type +reveal_type(arr[0](lit)) # E: Cannot call function of unknown type \ + # N: Revealed type is 'Any' T = TypeVar('T') def unify(func: Callable[[T, T], None]) -> T: pass @@ -2177,8 +2176,8 @@ reveal_type(d.get(a_key, u)) # N: Revealed type is 'Union[builtins.int, __main_ reveal_type(d.get(b_key, u)) # N: Revealed type is 'Union[builtins.str, __main__.Unrelated]' d.get(c_key, u) # E: TypedDict "Outer" has no key 'c' -reveal_type(d.pop(a_key)) # N: Revealed type is 'builtins.int' \ - # E: Key 'a' of TypedDict "Outer" cannot be deleted +reveal_type(d.pop(a_key)) # E: Key 'a' of TypedDict "Outer" cannot be deleted \ + # N: Revealed type is 'builtins.int' reveal_type(d.pop(b_key)) # N: Revealed type is 'builtins.str' d.pop(c_key) # E: TypedDict "Outer" has no key 'c' diff --git a/test-data/unit/check-modules.test b/test-data/unit/check-modules.test index e1780c017955..7ed4c137961f 100644 --- a/test-data/unit/check-modules.test +++ b/test-data/unit/check-modules.test @@ -1860,8 +1860,8 @@ class C: import stub reveal_type(stub.y) # N: Revealed type is 'builtins.int' -reveal_type(stub.z) # N: Revealed type is 'Any' \ - # E: Module has no attribute "z" +reveal_type(stub.z) # E: Module has no attribute "z" \ + # N: Revealed type is 'Any' [file stub.pyi] from substub import y as y @@ -2028,8 +2028,8 @@ def __getattr__(name): ... [case testModuleLevelGetattrNotStub36] # flags: --python-version 3.6 import has_getattr -reveal_type(has_getattr.any_attribute) # N: Revealed type is 'Any' # E: Module has no attribute "any_attribute" - +reveal_type(has_getattr.any_attribute) # E: Module has no attribute "any_attribute" \ + # N: Revealed type is 'Any' [file has_getattr.py] def __getattr__(name) -> str: ... @@ -2093,7 +2093,7 @@ def __getattr__(name: str) -> Any: ... [case testModuleLevelGetattrImportFromAs] from has_attr import name as n -reveal_type(name) # N: Revealed type is 'Any' # E: Name 'name' is not defined +reveal_type(name) # E: Name 'name' is not defined # N: Revealed type is 'Any' reveal_type(n) # N: Revealed type is 'Any' [file has_attr.pyi] diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test index 992a89c53dea..6d8626456403 100644 --- a/test-data/unit/check-namedtuple.test +++ b/test-data/unit/check-namedtuple.test @@ -134,7 +134,7 @@ X(0, 1) # ok X(0, 1, 2) # E: Too many arguments for "X" Y = namedtuple('Y', ['x', 'y'], defaults=(1, 2, 3)) # E: Too many defaults given in call to namedtuple() -Z = namedtuple('Z', ['x', 'y'], defaults='not a tuple') # E: Argument "defaults" to "namedtuple" has incompatible type "str"; expected "Optional[Iterable[Any]]" # E: List or tuple literal expected as the defaults argument to namedtuple() +Z = namedtuple('Z', ['x', 'y'], defaults='not a tuple') # E: List or tuple literal expected as the defaults argument to namedtuple() # E: Argument "defaults" to "namedtuple" has incompatible type "str"; expected "Optional[Iterable[Any]]" [builtins fixtures/list.pyi] diff --git a/test-data/unit/check-newsemanal.test b/test-data/unit/check-newsemanal.test index f5071ef8698e..38319d5ebe46 100644 --- a/test-data/unit/check-newsemanal.test +++ b/test-data/unit/check-newsemanal.test @@ -3049,8 +3049,8 @@ reveal_type(x) # N: Revealed type is '__main__.C' [case testNewAnalyzerIdentityAssignment7] C = C # E: Name 'C' is not defined -reveal_type(C) # N: Revealed type is 'Any' \ - # E: Name 'C' is not defined +reveal_type(C) # E: Name 'C' is not defined \ + # N: Revealed type is 'Any' [case testNewAnalyzerIdentityAssignment8] from typing import Final diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test index f08d0bd22d61..68cf443f9cb8 100644 --- a/test-data/unit/check-overloading.test +++ b/test-data/unit/check-overloading.test @@ -4563,6 +4563,7 @@ def f(*args): x: Union[int, str] f(x, x, x, x, x, x, x, x) [out] +main:11: note: Not all union combinations were tried because there are too many unions main:11: error: Argument 1 to "f" has incompatible type "Union[int, str]"; expected "int" main:11: error: Argument 2 to "f" has incompatible type "Union[int, str]"; expected "int" main:11: error: Argument 3 to "f" has incompatible type "Union[int, str]"; expected "int" @@ -4571,7 +4572,6 @@ main:11: error: Argument 5 to "f" has incompatible type "Union[int, str]"; expec main:11: error: Argument 6 to "f" has incompatible type "Union[int, str]"; expected "int" main:11: error: Argument 7 to "f" has incompatible type "Union[int, str]"; expected "int" main:11: error: Argument 8 to "f" has incompatible type "Union[int, str]"; expected "int" -main:11: note: Not all union combinations were tried because there are too many unions [case testSafeDunderOverlapInSubclass] from typing import overload @@ -4959,8 +4959,9 @@ def foo() -> None: ... def foo(iterable: Iterable[_T]) -> None: ... def foo(iterable = None) -> None: pass -foo(bar('lol').foo()) # E: Argument 1 to "bar" has incompatible type "str"; expected "int" \ - # E: Item "int" of "Union[A, int]" has no attribute "foo" +foo(bar('lol').foo()) # E: Item "int" of "Union[A, int]" has no attribute "foo" \ + # E: Argument 1 to "bar" has incompatible type "str"; expected "int" + [case testOverloadInferringArgumentsUsingContext1] from typing import Optional, List, overload, TypeVar diff --git a/test-data/unit/check-python38.test b/test-data/unit/check-python38.test index 8b27b2b1f76f..eeb964e990ef 100644 --- a/test-data/unit/check-python38.test +++ b/test-data/unit/check-python38.test @@ -30,15 +30,19 @@ def f(): ... # type: ignore [case testIgnoreScopeIssue1032] def f(a: int): ... f( - "IGNORE" + 1, + 2, ) # type: ignore [case testIgnoreScopeNested1] +def g(x: str) -> str: ... def f(a: int) -> int: ... f( f( - "IGNORE" - ) # type: ignore + g( + "IGNORE" + ) # type: ignore + ) ) [case testIgnoreScopeNested2] @@ -86,9 +90,9 @@ def g(x: int): ... [case testIgnoreScopeUnused1] # flags: --warn-unused-ignores ( # type: ignore # E: unused 'type: ignore' comment - "IGNORE" # type: ignore + "IGNORE" # type: ignore # E: unused 'type: ignore' comment + # type: ignore # E: unused 'type: ignore' comment - 0 # type: ignore # E: unused 'type: ignore' comment + 0 # type: ignore ) # type: ignore # E: unused 'type: ignore' comment [case testIgnoreScopeUnused2] diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test index 99a3157337cb..73c1c9ac6236 100644 --- a/test-data/unit/check-tuples.test +++ b/test-data/unit/check-tuples.test @@ -1216,8 +1216,8 @@ from typing import Union, Tuple tup: Union[Tuple[int, str], Tuple[int, int, str]] reveal_type(tup[0]) # N: Revealed type is 'builtins.int' reveal_type(tup[1]) # N: Revealed type is 'Union[builtins.str, builtins.int]' -reveal_type(tup[2]) # N: Revealed type is 'Union[Any, builtins.str]' \ - # E: Tuple index out of range +reveal_type(tup[2]) # E: Tuple index out of range \ + # N: Revealed type is 'Union[Any, builtins.str]' reveal_type(tup[:]) # N: Revealed type is 'Union[Tuple[builtins.int, builtins.str], Tuple[builtins.int, builtins.int, builtins.str]]' [builtins fixtures/tuple.pyi] @@ -1228,8 +1228,8 @@ from typing import Union, Tuple, List tup: Union[Tuple[int, str], List[int]] reveal_type(tup[0]) # N: Revealed type is 'builtins.int' reveal_type(tup[1]) # N: Revealed type is 'Union[builtins.str, builtins.int*]' -reveal_type(tup[2]) # N: Revealed type is 'Union[Any, builtins.int*]' \ - # E: Tuple index out of range +reveal_type(tup[2]) # E: Tuple index out of range \ + # N: Revealed type is 'Union[Any, builtins.int*]' reveal_type(tup[:]) # N: Revealed type is 'Union[Tuple[builtins.int, builtins.str], builtins.list[builtins.int*]]' [builtins fixtures/tuple.pyi] @@ -1240,4 +1240,4 @@ b = ("bar", 7) reveal_type(a + b) # N: Revealed type is 'Tuple[builtins.int, builtins.str, builtins.int, builtins.str, builtins.int]' -[builtins fixtures/tuple.pyi] \ No newline at end of file +[builtins fixtures/tuple.pyi] diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test index 51326c64ce43..e867b5a3f92f 100644 --- a/test-data/unit/check-typeddict.test +++ b/test-data/unit/check-typeddict.test @@ -1612,8 +1612,8 @@ td: Union[TDA, TDB] reveal_type(td.get('a')) # N: Revealed type is 'builtins.int' reveal_type(td.get('b')) # N: Revealed type is 'Union[builtins.str, builtins.int]' -reveal_type(td.get('c')) # N: Revealed type is 'Union[Any, builtins.int]' \ - # E: TypedDict "TDA" has no key 'c' +reveal_type(td.get('c')) # E: TypedDict "TDA" has no key 'c' \ + # N: Revealed type is 'Union[Any, builtins.int]' reveal_type(td['a']) # N: Revealed type is 'builtins.int' reveal_type(td['b']) # N: Revealed type is 'Union[builtins.str, builtins.int]' @@ -1639,8 +1639,8 @@ td: Union[TDA, TDB] reveal_type(td.pop('a')) # N: Revealed type is 'builtins.int' reveal_type(td.pop('b')) # N: Revealed type is 'Union[builtins.str, builtins.int]' -reveal_type(td.pop('c')) # N: Revealed type is 'Union[Any, builtins.int]' \ - # E: TypedDict "TDA" has no key 'c' +reveal_type(td.pop('c')) # E: TypedDict "TDA" has no key 'c' \ + # N: Revealed type is 'Union[Any, builtins.int]' [builtins fixtures/dict.pyi] [typing fixtures/typing-full.pyi] diff --git a/test-data/unit/check-unions.test b/test-data/unit/check-unions.test index dfad64ac202e..39dddb77c332 100644 --- a/test-data/unit/check-unions.test +++ b/test-data/unit/check-unions.test @@ -302,9 +302,9 @@ reveal_type(u('', 1, 1)) # N: Revealed type is 'Union[builtins.int*, builtins.s from typing import Union class A: pass def f(x: Union[int, str, A]): - x + object() # E: Unsupported operand types for + ("int" and "object") \ + x + object() # E: Unsupported left operand type for + ("A") \ + # E: Unsupported operand types for + ("int" and "object") \ # E: Unsupported operand types for + ("str" and "object") \ - # E: Unsupported left operand type for + ("A") \ # N: Left operand is of type "Union[int, str, A]" [case testNarrowingDownNamedTupleUnion] diff --git a/test-data/unit/cmdline.test b/test-data/unit/cmdline.test index e303f992344a..9f4eeb357b3c 100644 --- a/test-data/unit/cmdline.test +++ b/test-data/unit/cmdline.test @@ -1405,7 +1405,7 @@ class AnotherCustomClassDefinedBelow: [out] some_file.py:3: error: Unsupported operand types for + ("int" and "str") 42 + 'no way' - ^ + ^ some_file.py:11: error: Incompatible types in assignment (expression has type "AnotherCustomClassDefinedBelow", variable has type "OneCustomClassName") self.very_important_attribute_with_long_name: OneCustomClassNa... @@ -1413,8 +1413,8 @@ some_file.py:11: error: Incompatible types in assignment (expression has type some_file.py:11: error: Argument 1 to "some_interesting_method" of "OneCustomClassName" has incompatible type "Union[int, str, float]"; expected "AnotherCustomClassDefinedBelow" - ...t_attribute_with_long_name: OneCustomClassName = OneCustomClassName().... - ^ + ...OneCustomClassName = OneCustomClassName().some_interesting_method(arg) + ^ [case testShowSourceCodeSnippetsBlockingError] # cmd: mypy --pretty --show-error-codes some_file.py diff --git a/test-data/unit/fine-grained.test b/test-data/unit/fine-grained.test index ad2cba3dbf15..3de5c6e07bf7 100644 --- a/test-data/unit/fine-grained.test +++ b/test-data/unit/fine-grained.test @@ -2592,11 +2592,11 @@ class Wrapper: [out] main:3: note: Revealed type is 'builtins.int' == -main:3: note: Revealed type is 'Any' main:3: error: No overload variant of "foo" of "Wrapper" matches argument type "int" main:3: note: Possible overload variants: main:3: note: def foo(cls: Wrapper, x: int) -> int main:3: note: def foo(cls: Wrapper, x: str) -> str +main:3: note: Revealed type is 'Any' [case testRefreshGenericClass] from typing import TypeVar, Generic diff --git a/test-data/unit/parse-python2.test b/test-data/unit/parse-python2.test index f175264fd177..0dac6affedff 100644 --- a/test-data/unit/parse-python2.test +++ b/test-data/unit/parse-python2.test @@ -594,19 +594,19 @@ MypyFile:1( ExpressionStmt:1( IndexExpr:1( NameExpr(x) - SliceExpr:-1( + SliceExpr:1( NameExpr(y) ))) ExpressionStmt:2( IndexExpr:2( NameExpr(x) - SliceExpr:-1( + SliceExpr:2( NameExpr(y) NameExpr(z)))) ExpressionStmt:3( IndexExpr:3( NameExpr(x) - SliceExpr:-1( + SliceExpr:3( NameExpr(y))))) diff --git a/test-data/unit/parse.test b/test-data/unit/parse.test index 09a908c5d20f..1538061c9e02 100644 --- a/test-data/unit/parse.test +++ b/test-data/unit/parse.test @@ -1207,25 +1207,25 @@ MypyFile:1( ExpressionStmt:1( IndexExpr:1( NameExpr(x) - SliceExpr:-1( + SliceExpr:1( IntExpr(1) IntExpr(2)))) ExpressionStmt:2( IndexExpr:2( NameExpr(x) - SliceExpr:-1( + SliceExpr:2( IntExpr(1)))) ExpressionStmt:3( IndexExpr:3( NameExpr(x) - SliceExpr:-1( + SliceExpr:3( IntExpr(1) ))) ExpressionStmt:4( IndexExpr:4( NameExpr(x) - SliceExpr:-1( + SliceExpr:4( )))) @@ -1240,35 +1240,35 @@ MypyFile:1( ExpressionStmt:1( IndexExpr:1( NameExpr(x) - SliceExpr:-1( + SliceExpr:1( IntExpr(1) IntExpr(2) IntExpr(3)))) ExpressionStmt:2( IndexExpr:2( NameExpr(x) - SliceExpr:-1( + SliceExpr:2( IntExpr(1) IntExpr(2)))) ExpressionStmt:3( IndexExpr:3( NameExpr(x) - SliceExpr:-1( + SliceExpr:3( IntExpr(1) IntExpr(2)))) ExpressionStmt:4( IndexExpr:4( NameExpr(x) - SliceExpr:-1( + SliceExpr:4( IntExpr(2)))) ExpressionStmt:5( IndexExpr:5( NameExpr(x) - SliceExpr:-1( + SliceExpr:5( IntExpr(1) IntExpr(2))))) @@ -3328,92 +3328,92 @@ MypyFile:1( x = 'mypy' f'Hello {x}' [out] -MypyFile:1( - AssignmentStmt:1( - NameExpr(x) - StrExpr(mypy)) - ExpressionStmt:2( - CallExpr:2( - MemberExpr:2( - StrExpr() - join) - Args( - ListExpr:2( - StrExpr(Hello ) - CallExpr:2( - MemberExpr:2( - StrExpr({:{}}) - format) - Args( +MypyFile:1( + AssignmentStmt:1( + NameExpr(x) + StrExpr(mypy)) + ExpressionStmt:2( + CallExpr:2( + MemberExpr:2( + StrExpr() + join) + Args( + ListExpr:2( + StrExpr(Hello ) + CallExpr:2( + MemberExpr:2( + StrExpr({:{}}) + format) + Args( NameExpr(x)))))))) [case testFStringWithConversion] x = 'mypy' F'Hello {x!r}' [out] -MypyFile:1( - AssignmentStmt:1( - NameExpr(x) - StrExpr(mypy)) - ExpressionStmt:2( - CallExpr:2( - MemberExpr:2( - StrExpr() - join) - Args( - ListExpr:2( - StrExpr(Hello ) - CallExpr:2( - MemberExpr:2( - StrExpr({!r:{}}) - format) - Args( +MypyFile:1( + AssignmentStmt:1( + NameExpr(x) + StrExpr(mypy)) + ExpressionStmt:2( + CallExpr:2( + MemberExpr:2( + StrExpr() + join) + Args( + ListExpr:2( + StrExpr(Hello ) + CallExpr:2( + MemberExpr:2( + StrExpr({!r:{}}) + format) + Args( NameExpr(x)))))))) [case testFStringWithOnlyFormatSpecifier] x = 'mypy' f'Hello {x:<30}' [out] -MypyFile:1( - AssignmentStmt:1( - NameExpr(x) - StrExpr(mypy)) - ExpressionStmt:2( - CallExpr:2( - MemberExpr:2( - StrExpr() - join) - Args( - ListExpr:2( - StrExpr(Hello ) - CallExpr:2( - MemberExpr:2( - StrExpr({:{}}) - format) - Args( +MypyFile:1( + AssignmentStmt:1( + NameExpr(x) + StrExpr(mypy)) + ExpressionStmt:2( + CallExpr:2( + MemberExpr:2( + StrExpr() + join) + Args( + ListExpr:2( + StrExpr(Hello ) + CallExpr:2( + MemberExpr:2( + StrExpr({:{}}) + format) + Args( NameExpr(x)))))))) [case testFStringWithFormatSpecifierAndConversion] x = 'mypy' f'Hello {x!s:<30}' [out] -MypyFile:1( - AssignmentStmt:1( - NameExpr(x) - StrExpr(mypy)) - ExpressionStmt:2( - CallExpr:2( - MemberExpr:2( - StrExpr() - join) - Args( - ListExpr:2( - StrExpr(Hello ) - CallExpr:2( - MemberExpr:2( - StrExpr({!s:{}}) - format) - Args( +MypyFile:1( + AssignmentStmt:1( + NameExpr(x) + StrExpr(mypy)) + ExpressionStmt:2( + CallExpr:2( + MemberExpr:2( + StrExpr() + join) + Args( + ListExpr:2( + StrExpr(Hello ) + CallExpr:2( + MemberExpr:2( + StrExpr({!s:{}}) + format) + Args( NameExpr(x)))))))) [case testFStringWithFormatSpecifierExpression] @@ -3421,24 +3421,24 @@ x = 'mypy' y = 30 f'Hello {x!s:<{y+y}}' [out] -MypyFile:1( - AssignmentStmt:1( - NameExpr(x) - StrExpr(mypy)) - AssignmentStmt:2( - NameExpr(y) - IntExpr(30)) - ExpressionStmt:3( - CallExpr:3( - MemberExpr:3( - StrExpr() - join) - Args( - ListExpr:3( - StrExpr(Hello ) - CallExpr:3( - MemberExpr:3( - StrExpr({!s:{}}) - format) - Args( +MypyFile:1( + AssignmentStmt:1( + NameExpr(x) + StrExpr(mypy)) + AssignmentStmt:2( + NameExpr(y) + IntExpr(30)) + ExpressionStmt:3( + CallExpr:3( + MemberExpr:3( + StrExpr() + join) + Args( + ListExpr:3( + StrExpr(Hello ) + CallExpr:3( + MemberExpr:3( + StrExpr({!s:{}}) + format) + Args( NameExpr(x)))))))) diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test index c450b1f9ed92..3a0af9fb9af6 100644 --- a/test-data/unit/pythoneval.test +++ b/test-data/unit/pythoneval.test @@ -295,8 +295,8 @@ reveal_type(open(file='x', mode='rb')) mode = 'rb' reveal_type(open(mode=mode, file='r')) [out] -_testOpenReturnTypeInferenceSpecialCases.py:1: note: Revealed type is 'typing.TextIO' _testOpenReturnTypeInferenceSpecialCases.py:1: error: Too few arguments for "open" +_testOpenReturnTypeInferenceSpecialCases.py:1: note: Revealed type is 'typing.TextIO' _testOpenReturnTypeInferenceSpecialCases.py:2: note: Revealed type is 'typing.BinaryIO' _testOpenReturnTypeInferenceSpecialCases.py:3: note: Revealed type is 'typing.BinaryIO' _testOpenReturnTypeInferenceSpecialCases.py:5: note: Revealed type is 'typing.IO[Any]' diff --git a/test-data/unit/semanal-expressions.test b/test-data/unit/semanal-expressions.test index 1ddc9c20e587..98bf32708f1b 100644 --- a/test-data/unit/semanal-expressions.test +++ b/test-data/unit/semanal-expressions.test @@ -115,20 +115,20 @@ MypyFile:1( ExpressionStmt:2( IndexExpr:2( NameExpr(x [__main__.x]) - SliceExpr:-1( + SliceExpr:2( NameExpr(y [__main__.y]) NameExpr(z [__main__.z]) NameExpr(x [__main__.x])))) ExpressionStmt:3( IndexExpr:3( NameExpr(x [__main__.x]) - SliceExpr:-1( + SliceExpr:3( ))) ExpressionStmt:4( IndexExpr:4( NameExpr(x [__main__.x]) - SliceExpr:-1( + SliceExpr:4( NameExpr(y [__main__.y])))))