From 0c2ec6a57e6f4b121590fdc3c3ede684a3cbc816 Mon Sep 17 00:00:00 2001 From: Jukka Lehtosalo Date: Thu, 19 Sep 2019 00:27:11 +0300 Subject: [PATCH] Document error codes (#7451) There's a general page about what error pages and for, and I document each error code that is supported, often with code examples. --- docs/source/command_line.rst | 12 +- docs/source/common_issues.rst | 8 + docs/source/config_file.rst | 4 + docs/source/error_code_list.rst | 618 +++++++++++++++++++++++++++ docs/source/error_code_list2.rst | 176 ++++++++ docs/source/error_codes.rst | 56 +++ docs/source/index.rst | 3 + test-data/unit/check-errorcodes.test | 4 +- 8 files changed, 878 insertions(+), 3 deletions(-) create mode 100644 docs/source/error_code_list.rst create mode 100644 docs/source/error_code_list2.rst create mode 100644 docs/source/error_codes.rst diff --git a/docs/source/command_line.rst b/docs/source/command_line.rst index ee6a50a96bd5..138b4d7f009f 100644 --- a/docs/source/command_line.rst +++ b/docs/source/command_line.rst @@ -497,12 +497,20 @@ in error messages. main.py:3: error: Unsupported operand types for + ("int" and "str") ``--show-column-numbers`` - This flag will add column offsets to error messages, - for example, the following indicates an error in line 12, column 9 + This flag will add column offsets to error messages. + For example, the following indicates an error in line 12, column 9 (note that column offsets are 0-based):: main.py:12:9: error: Unsupported operand types for / ("int" and "str") +``--show-error-codes`` + This flag will add an error code ``[]`` to error messages. The error + code is shown after each error message:: + + prog.py:1: error: "str" has no attribute "trim" [attr-defined] + + See :ref:`error-codes` for more information. + ``--no-color-output`` This flag will disable color output in error messages, enabled by default. diff --git a/docs/source/common_issues.rst b/docs/source/common_issues.rst index c0c8d7e9d8d1..e4741d34ce1d 100644 --- a/docs/source/common_issues.rst +++ b/docs/source/common_issues.rst @@ -124,6 +124,14 @@ error: The second line is now fine, since the ignore comment causes the name ``frobnicate`` to get an implicit ``Any`` type. +.. note:: + + You can use the form ``# type: ignore[]`` to only ignore + specific errors on the line. This way you are less likely to + silence unexpected errors that are not safe to ignore, and this + will also document what the purpose of the comment is. See + :ref:`error-codes` for more information. + .. note:: The ``# type: ignore`` comment will only assign the implicit ``Any`` diff --git a/docs/source/config_file.rst b/docs/source/config_file.rst index 905ca77e98d4..a7d2c75dfc08 100644 --- a/docs/source/config_file.rst +++ b/docs/source/config_file.rst @@ -441,12 +441,16 @@ section of the command line docs. ``show_column_numbers`` (bool, default False) Shows column numbers in error messages. +``show_error_codes`` (bool, default False) + Shows error codes in error messages. See :ref:`error-codes` for more information. + ``color_output`` (bool, default True) Shows error messages with color enabled. ``error_summary`` (bool, default True) Shows a short summary line after error messages. + Advanced options ---------------- diff --git a/docs/source/error_code_list.rst b/docs/source/error_code_list.rst new file mode 100644 index 000000000000..6948e51f7de5 --- /dev/null +++ b/docs/source/error_code_list.rst @@ -0,0 +1,618 @@ +.. _error-code-list: + +Error codes enabled by default +============================== + +This section documents various errors codes that mypy can generate +with default options. See :ref:`error-codes` for general documentation +about error codes. :ref:`error-codes-optional` documents additional +error codes that you can enable. + +Check that attribute exists [attr-defined] +------------------------------------------ + +Mypy checks that an attribute is defined in the target class or module +when using the dot operator. This applies to both getting and setting +an attribute. New attributes are defined by assignments in the class +body, or assignments to ``self.x`` in methods. These assignments don't +generate ``attr-defined`` errors. + +Example: + +.. code-block:: python + + class Resource: + def __init__(self, name: str) -> None: + self.name = name + + r = Resouce('x') + print(r.name) # OK + print(r.id) # Error: "Resource" has no attribute "id" [attr-defined] + r.id = 5 # Error: "Resource" has no attribute "id" [attr-defined] + +This error code is also generated if an imported name is not defined +in the module in a ``from ... import`` statement (as long as the +target module can be found): + +.. code-block:: python + + # Error: Module 'os' has no attribute 'non_existent' [attr-defined] + from os import non_existent + +A reference to a missing attribute is given the ``Any`` type. In the +above example, the type of ``non_existent`` will be ``Any``, which can +be important if you silence the error. + +Check that attribute exists in each union item [union-attr] +----------------------------------------------------------- + +If you access the attribute of a value with a union type, mypy checks +that the attribute is defined for *every* type in that +union. Otherwise the operation can fail at runtime. This also applies +to optional types. + +Example: + +.. code-block:: python + + from typing import Union + + class Cat: + def sleep(self) -> None: ... + def miaow(self) -> None: ... + + class Dog: + def sleep(self) -> None: ... + def follow_me(self) -> None: ... + + def func(animal: Union[Cat, Dog]) -> None: + # OK: 'sleep' is defined for both Cat and Dog + animal.sleep() + # Error: Item "Cat" of "Union[Cat, Dog]" has no attribute "follow_me" [union-attr] + animal.follow_me() + +You can often work around these errors by using ``assert isinstance(obj, ClassName)`` +or ``assert obj is not None`` to tell mypy that you know that the type is more specific +than what mypy thinks. + +Check that name is defined [name-defined] +----------------------------------------- + +Mypy expects that all references to names have a corresponding +definition in an active scope, such as an assignment, function +definition or an import. This can catch missing definitions, missing +imports, and typos. + +This example accidentally calls ``sort()`` instead of ``sorted()``: + +.. code-block:: python + + x = sort([3, 2, 4]) # Error: Name 'sort' is not defined [name-defined] + +Check arguments in calls [call-arg] +----------------------------------- + +Mypy expects that the number and names of arguments match the called function. +Note that argument type checks have a separate error code ``arg-type``. + +Example: + +.. code-block:: python + + from typing import Sequence + + def greet(name: str) -> None: + print('hello', name) + + greet('jack') # OK + greet('jill', 'jack') # Error: Too many arguments for "greet" [call-arg] + +Check argument types [arg-type] +------------------------------- + +Mypy checks that argument types in a call match the declared argument +types in the signature of the called function (if one exists). + +Example: + +.. code-block:: python + + from typing import List, Optional + + def first(x: List[int]) -> Optional[int]: + return x[0] if x else 0 + + t = (5, 4) + # Error: Argument 1 to "first" has incompatible type "Tuple[int, int]"; + # expected "List[int]" [arg-type] + print(first(t)) + +Check calls to overloaded functions [call-overload] +--------------------------------------------------- + +When you call an overloaded function, mypy checks that at least one of +the signatures of the overload items match the argument types in the +call. + +Example: + +.. code-block:: python + + from typing import overload, Optional + + @overload + def inc_maybe(x: None) -> None: ... + + @overload + def inc_maybe(x: int) -> int: ... + + def inc_maybe(x: Optional[int]) -> Optional[int]: + if x is None: + return None + else: + return x + 1 + + inc_maybe(None) # OK + inc_maybe(5) # OK + + # Error: No overload variant of "inc_maybe" matches argument type "float" [call-overload] + inc_maybe(1.2) + +Check validity of types [valid-type] +------------------------------------ + +Mypy checks that each type annotation and any expression that +represents a type is a valid type. Examples of valid types include +classes, union types, callable types, type aliases, and literal types. +Examples of invalid types include bare integer literals, functions, +variables, and modules. + +This example incorrectly uses the function ``log`` as a type: + +.. code-block:: python + + from typing import List + + def log(x: object) -> None: + print('log:', repr(x)) + + # Error: Function "t.log" is not valid as a type [valid-type] + def log_all(objs: List[object], f: log) -> None: + for x in objs: + f(x) + +You can use ``Callable`` as the type for callable objects: + +.. code-block:: python + + from typing import List, Callable + + # OK + def log_all(objs: List[object], f: Callable[[object], None]) -> None: + for x in objs: + f(x) + +Require annotation if variable type is unclear [var-annotated] +-------------------------------------------------------------- + +In some cases mypy can't infer the type of a variable without an +explicit annotation. Mypy treats this as an error. This typically +happens when you initialize a variable with an empty collection or +``None``. If mypy can't infer the collection item type, mypy replaces +any parts of the type it couldn't infer with ``Any`` and generates an +error. + +Example with an error: + +.. code-block:: python + + class Bundle: + def __init__(self) -> None: + # Error: Need type annotation for 'items' + # (hint: "items: List[] = ...") [var-annotated] + self.items = [] + + reveal_type(Bundle().items) # list[Any] + +To address this, we add an explicit annotation: + +.. code-block:: python + + from typing import List + + class Bundle: + def __init__(self) -> None: + self.items: List[str] = [] # OK + + reveal_type(Bundle().items) # list[str] + +Check validity of overrides [override] +-------------------------------------- + +Mypy checks that an overridden method or attribute is compatible with +the base class. A method in a subclass must accept all arguments +that the base class method accepts, and the return type must conform +to the return type in the base class (Liskov substitution principle). + +Argument types can be more general is a subclass (i.e., they can vary +contravariantly). The return type can be narrowed in a subclass +(i.e., it can vary covariantly). It's okay to define additional +arguments in a subclass method, as long all extra arguments have default +values or can be left out (``*args``, for example). + +Example: + +.. code-block:: python + + from typing import Optional, Union + + class Base: + def method(self, + arg: int) -> Optional[int]: + ... + + class Derived(Base): + def method(self, + arg: Union[int, str]) -> int: # OK + ... + + class DerivedBad(Base): + # Error: Argument 1 of "method" is incompatible with "Base" [override] + def method(self, + arg: bool) -> int: + ... + +Check that function returns a value [return] +-------------------------------------------- + +If a function has a non-``None`` return type, mypy expects that the +function always explicitly returns a value (or raises an exception). +The function should not fall off the end of the function, since this +is often a bug. + +Example: + +.. code-block:: python + + # Error: Missing return statement [return] + def show(x: int) -> int: + print(x) + + # Error: Missing return statement [return] + def pred1(x: int) -> int: + if x > 0: + return x - 1 + + # OK + def pred2(x: int) -> int: + if x > 0: + return x - 1 + else: + raise ValueError('not defined for zero') + +Check that return value is compatible [return-value] +---------------------------------------------------- + +Mypy checks that the returned value is compatible with the type +signature of the function. + +Example: + +.. code-block:: python + + def func(x: int) -> str: + # Error: Incompatible return value type (got "int", expected "str") [return-value] + return x + 1 + +Check types in assignment statement [assignment] +------------------------------------------------ + +Mypy checks that the assigned expression is compatible with the +assignment target (or targets). + +Example: + +.. code-block:: python + + class Resource: + def __init__(self, name: str) -> None: + self.name = name + + r = Resource('A') + + r.name = 'B' # OK + + # Error: Incompatible types in assignment (expression has type "int", + # variable has type "str") [assignment] + r.name = 5 + +Check type variable values [type-var] +------------------------------------- + +Mypy checks that value of a type variable is compatible with a value +restriction or the upper bound type. + +Example: + +.. code-block:: python + + from typing import TypeVar + + T1 = TypeVar('T1', int, float) + + def add(x: T1, y: T1) -> T1: + return x + y + + add(4, 5.5) # OK + + # Error: Value of type variable "T1" of "add" cannot be "str" [type-var] + add('x', 'y') + +Check uses of various operators [operator] +------------------------------------------ + +Mypy checks that operands support a binary or unary operation, such as +``+`` or ``~``. Indexing operations are so common that they have their +own error code ``index`` (see below). + +Example: + +.. code-block:: python + + # Error: Unsupported operand types for + ("int" and "str") [operator] + 1 + 'x' + +Check indexing operations [index] +--------------------------------- + +Mypy checks that the indexed value in indexing operation such as +``x[y]`` supports indexing, and that the index expression has a valid +type. + +Example: + +.. code-block:: python + + a = {'x': 1, 'y': 2} + + a['x'] # OK + + # Error: Invalid index type "int" for "Dict[str, int]"; expected type "str" [index] + print(a[1]) + + # Error: Invalid index type "bytes" for "Dict[str, int]"; expected type "str" [index] + a[b'x'] = 4 + +Check list items [list-item] +---------------------------- + +When constructing a list using ``[item, ...]``, mypy checks that each item +is compatible with the list type that is inferred from the surrounding +context. + +Example: + +.. code-block:: python + + from typing import List + + # Error: List item 0 has incompatible type "int"; expected "str" [list-item] + a: List[str] = [0] + +Check dict items [dict-item] +---------------------------- + +When constructing a dictionary using ``{key: value, ...}`` or ``dict(key=value, ...)``, +mypy checks that each key and value is compatible with the dictionary type that is +inferred from the surrounding context. + +Example: + +.. code-block:: python + + from typing import Dict + + # Error: Dict entry 0 has incompatible type "str": "str"; expected "str": "int" [dict-item] + d: Dict[str, int] = {'key': 'value'} + +Check TypedDict items [typeddict-item] +-------------------------------------- + +When constructing a TypedDict object, mypy checks that each key and value is compatible +with the TypedDict type that is inferred from the surrounding context. + +Example: + +.. code-block:: python + + from typing_extensions import TypedDict + + class Point(TypedDict): + x: int + y: int + + # Error: Incompatible types (expression has type "float", + # TypedDict item "x" has type "int") [typeddict-item] + p: Point = {'x': 1.2, 'y': 4} + +Check that type of target is known [has-type] +--------------------------------------------- + +Mypy sometimes generates an error when it hasn't inferred any type for +a variable being referenced. This can happen for references to +variables that are initialized later in the source file, and for +references across modules that form an import cycle. When this +happens, the reference gets an implicit ``Any`` type. + +In this example the definitions of ``x`` and ``y`` are circular: + +.. code-block:: python + + class Problem: + def set_x(self) -> None: + # Error: Cannot determine type of 'y' [has-type] + self.x = self.y + + def set_y(self) -> None: + self.y = self.x + +To work around this error, you can add an explicit type annotation to +the target variable or attribute. Sometimes you can also reorganize +the code so that the definition of the variable is placed earlier than +the reference to the variable in a source file. Untangling cyclic +imports may also help. + +We add an explicit annotation to the ``y`` attribute to work around +the issue: + +.. code-block:: python + + class Problem: + def set_x(self) -> None: + self.x = self.y # OK + + def set_y(self) -> None: + self.y: int = self.x # Added annotation here + +Check that import target can be found [import] +---------------------------------------------- + +Mypy generates an error if it can't find the source code or a stub file +for an imported module. + +Example: + +.. code-block:: python + + # Error: Cannot find module named 'acme' [import] + import acme + +See :ref:`ignore-missing-imports` for how to work around these errors. + +Check that each name is defined once [no-redef] +----------------------------------------------- + +Mypy may generate an error if you have multiple definitions for a name +in the same namespace. The reason is that this is often an error, as +the second definition may overwrite the first one. Also, mypy often +can't be able to determine whether references point to the first or +the second definition, which would compromise type checking. + +If you silence this error, all references to the defined name refer to +the *first* definition. + +Example: + +.. code-block:: python + + class A: + def __init__(self, x: int) -> None: ... + + class A: # Error: Name 'A' already defined on line 1 [no-redef] + def __init__(self, x: str) -> None: ... + + # Error: Argument 1 to "A" has incompatible type "str"; expected "int" + # (the first definition wins!) + A('x') + +Check that called function returns a value [func-returns-value] +--------------------------------------------------------------- + +Mypy reports an error if you call a function with a ``None`` +return type and don't ignore the return value, as this is +usually (but not always) a programming error. + +In this example, the ``if f()`` check is always false since ``f`` +returns ``None``: + +.. code-block:: python + + def f() -> None: + ... + + # OK: we don't do anything with the return value + f() + + # Error: "f" does not return a value [func-returns-value] + if f(): + print("not false") + +Check instantiation of abstract classes [abstract] +-------------------------------------------------- + +Mypy generates an error if you try to instantiate an abstract base +class (ABC). An abtract base class is a class with at least one +abstract method or attribute. (See also `Python +abc module documentation `_.) + +Sometimes a class is made accidentally abstract, often due to an +unimplemented abstract method. In a case like this you need to provide +an implementation for the method to make the class concrete +(non-abstract). + +Example: + +.. code-block:: python + + from abc import ABCMeta, abstractmethod + + class Persistent(metaclass=ABCMeta): + @abstractmethod + def save(self) -> None: ... + + class Thing(Persistent): + def __init__(self) -> None: + ... + + ... # No "save" method + + # Error: Cannot instantiate abstract class 'Thing' with abstract attribute 'save' [abstract] + t = Thing() + +Check the target of NewType [valid-newtype] +------------------------------------------- + +The target of a ``NewType`` definition must be a class type. It can't +be a union type, ``Any``, or various other special types. + +You can also get this error if the target has been imported from a +module whose source mypy cannot find, since any such definitions are +treated by mypy as values with ``Any`` types. Example: + +.. code-block:: python + + from typing import NewType + + # The source for "acme" is not available for mypy + from acme import Entity # type: ignore + + # Error: Argument 2 to NewType(...) must be subclassable (got "Any") [valid-newtype] + UserEntity = NewType('UserEntity', Entity) + +To work around the issue, you can either give mypy access to the sources +for ``acme`` or create a stub file for the module. See :ref:`ignore-missing-imports` +for more information. + +Report syntax errors [syntax] +----------------------------- + +If the code being checked is not syntactically valid, mypy issues a +syntax error. Most, but not all, syntax errors are *blocking errors*: +they can't be ignored with a ``# type: ignore`` comment. + +Miscellaneous checks [misc] +--------------------------- + +Mypy performs numerous other, less commonly failing checks that don't +have specific error codes. These use the ``misc`` error code. Other +than being used for multiple unrelated errors, the ``misc`` error code +is not special. For example, you can ignore all errors in this +category by using ``# type: ignore[misc]`` comment. Since these errors +are not expected to be common, it's unlikely that you'll see two +*different* errors with the ``misc`` code on a single line -- though +this can certainly happen once in a while. + +.. note:: + + Future mypy versions will likely add new error codes for some errors + that currently use the ``misc`` error code. diff --git a/docs/source/error_code_list2.rst b/docs/source/error_code_list2.rst new file mode 100644 index 000000000000..4cfd2f2613ab --- /dev/null +++ b/docs/source/error_code_list2.rst @@ -0,0 +1,176 @@ +.. _error-codes-optional: + +Error codes for optional checks +=============================== + +This section documents various errors codes that mypy generates only +if you enable certain options. See :ref:`error-codes` for general +documentation about error codes. :ref:`error-code-list` documents +error codes that are enabled by default. + +.. note:: + + The examples in this section use :ref:`inline configuration + ` to specify mypy options. You can also set the same + options by using a :ref:`configuration file ` or + :ref:`command-line options `. + +Check that type arguments exist [type-arg] +------------------------------------------ + +If you use ``--disallow-any-generics``, mypy requires that each generic +type has values for each type argument. For example, the types ``List`` or +``dict`` would be rejected. You should instead use types like ``List[int]`` or +``Dict[str, int]``. Any omitted generic type arguments get implicit ``Any`` +values. The type ``List`` is equivalent to ``List[Any]``, and so on. + +Example: + +.. code-block:: python + + # mypy: disallow-any-generics + + from typing import List + + # Error: Missing type parameters for generic type "List" [type-arg] + def remove_dups(items: List) -> List: + ... + +Check that every function has an annotation [no-untyped-def] +------------------------------------------------------------ + +If you use ``--disallow-untyped-defs``, mypy requires that all functions +have annotations (either a Python 3 annotation or a type comment). + +Example: + +.. code-block:: python + + # mypy: disallow-untyped-defs + + def inc(x): # Error: Function is missing a type annotation [no-untyped-def] + return x + 1 + + def inc_ok(x: int) -> int: # OK + return x + 1 + + class Counter: + # Error: Function is missing a type annotation [no-untyped-def] + def __init__(self): + self.value = 0 + + class CounterOk: + # OK: An explicit "-> None" is needed if "__init__" takes no arguments + def __init__(self) -> None: + self.value = 0 + +Check that cast is not redundant [redundant-cast] +------------------------------------------------- + +If you use ``--warn-redundant-casts``, mypy will generate an error if the source +type of a cast is the same as the target type. + +Example: + +.. code-block:: python + + # mypy: warn-redundant-casts + + from typing import cast + + Count = int + + def example(x: Count) -> int: + # Error: Redundant cast to "int" [redundant-cast] + return cast(int, x) + +Check that comparisons are overlapping [comparison-overlap] +----------------------------------------------------------- + +If you use ``--strict-equality``, mypy will generate an error if it +thinks that a comparison operation is always true or false. These are +often bugs. Sometimes mypy is too picky and the comparison can +actually be useful. Instead of disabling strict equality checking +everywhere, you can use ``# type: ignore[comparison-overlap]`` to +ignore the issue on a particular line only. + +Example: + +.. code-block:: python + + # mypy: strict-equality + + def is_magic(x: bytes) -> bool: + # Error: Non-overlapping equality check (left operand type: "bytes", + # right operand type: "str") [comparison-overlap] + return x == 'magic' + +We can fix the error by changing the string literal to a bytes +literal: + +.. code-block:: python + + # mypy: strict-equality + + def is_magic(x: bytes) -> bool: + return x == b'magic' # OK + +Check that no untyped functions are called [no-untyped-call] +------------------------------------------------------------ + +If you use ``--disallow-untyped-calls``, mypy generates an error when you +call an unannotated function in an annotated function. + +Example: + +.. code-block:: python + + # mypy: disallow-untyped-calls + + def do_it() -> None: + # Error: Call to untyped function "bad" in typed context [no-untyped-call] + bad() + + def bad(): + ... + + +Check that function does not return Any value [no-any-return] +------------------------------------------------------------- + +If you use ``--warn-return-any``, mypy generates an error if you return a +value with an ``Any`` type in a function that is annotated to return a +non-``Any`` value. + +Example: + +.. code-block:: python + + # mypy: warn-return-any + + def fields(s): + return s.split(',') + + def first_field(x: str) -> str: + # Error: Returning Any from function declared to return "str" [no-any-return] + return fields(x)[0] + +Check that types have no Any components due to missing imports [no-any-unimported] +---------------------------------------------------------------------------------- + +If you use ``--disallow-any-unimported``, mypy generates an error if a component of +a type becomes ``Any`` because mypy couldn't resolve an import. These "stealth" +``Any`` types can be surprising and accidentally cause imprecise type checking. + +In this example, we assume that mypy can't find the module ``animals``, which means +that ``Cat`` falls back to ``Any`` in a type annotation: + +.. code-block:: python + + # mypy: disallow-any-unimported + + from animals import Cat # type: ignore + + # Error: Argument 1 to "feed" becomes "Any" due to an unfollowed import [no-any-unimported] + def feed(cat: Cat) -> None: + ... diff --git a/docs/source/error_codes.rst b/docs/source/error_codes.rst new file mode 100644 index 000000000000..aafe95d0f289 --- /dev/null +++ b/docs/source/error_codes.rst @@ -0,0 +1,56 @@ +.. _error-codes: + +Error codes +=========== + +Mypy can optionally display an error code such as ``[attr-defined]`` +after each error message. Error codes serve two purposes: + +1. It's possible to silence specific error codes on a line using ``# + type: ignore[code]``. This way you won't accidentally ignore other, + potentially more serious errors. + +2. The error code can be used to find documentation about the error. + The next two topics (:ref:`error-code-list` and + :ref:`error-codes-optional`) document the various error codes + mypy can report. + +Most error codes are shared between multiple related error messages. +Error codes may change in future mypy releases. + + + +Displaying error codes +---------------------- + +Error codes are not displayed by default. Use ``--show-error-codes`` +to display error codes. Error codes are shown inside square brackets: + +.. code-block:: text + + $ mypy --show-error-codes prog.py + prog.py:1: error: "str" has no attribute "trim" [attr-defined] + +Silencing errors based on error codes +------------------------------------- + +You can use a special comment ``# type: ignore[code, ...]`` to only +ignore errors with a specific error code (or codes) on a particular +line. This can be used even if you have not configured mypy to show +error codes. Currently it's only possible to disable arbitrary error +codes on individual lines using this comment. + +.. note:: + + There are command-line flags and config file settings for enabling + certain optional error codes, such as ``--disallow-untype-defs``, + which enables the ``no-untyped-def`` error code. + +This example shows how to ignore an error about an imported name mypy +thinks is undefined: + +.. code-block:: python + + # 'foo' is defined in 'foolib', even though mypy can't see the + # definition. + from foolib import foo # type: ignore[attr-defined] diff --git a/docs/source/index.rst b/docs/source/index.rst index f5a3e2b62808..42c3acd30eec 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -66,6 +66,9 @@ Mypy is a static type checker for Python 3 and Python 2.7. common_issues supported_python_features + error_codes + error_code_list + error_code_list2 python36 additional_features faq diff --git a/test-data/unit/check-errorcodes.test b/test-data/unit/check-errorcodes.test index 6090cc22ebf6..c651f805bb1d 100644 --- a/test-data/unit/check-errorcodes.test +++ b/test-data/unit/check-errorcodes.test @@ -270,6 +270,7 @@ class B(A): a: A a.x = '' # E: Incompatible types in assignment (expression has type "str", variable has type "int") [assignment] + [case testErrorCodeMissingTypeArg] # flags: --disallow-any-generics from typing import List, TypeVar @@ -404,7 +405,8 @@ c = {} # E: Expected TypedDict key 'x' but found no keys [typeddict-item] [builtins fixtures/dict.pyi] [case testErrorCodeCannotDetermineType] -x # E: Cannot determine type of 'x' [has-type] +y = x # E: Cannot determine type of 'x' [has-type] +reveal_type(y) # N: Revealed type is 'Any' x = None [case testErrorCodeRedundantCast]