Merge remote-tracking branch 'upstream/master' into variance

Author: spkersten

README.md

@@ -8,13 +8,20 @@ What is mypy?
 -------------
 
 Mypy is an optional static type checker for Python.  You can add type
-annotations to your Python programs and use mypy to type check them
-statically to find errors before running them.  You can also
-seamlessly mix dynamic and static typing in your programs, so you can
-always fall back to dynamic typing.  Mypy programs are valid Python
-3.x and you use a normal Python interpreter to run them. There is
-essentially no performance overhead when using mypy, since mypy does
-not introduce additional runtime type checking.
+hints to your Python programs using the upcoming standard for type
+annotations introduced in Python 3.5 beta 1 (PEP 484), and use mypy to
+type check them statically. Find bugs in your programs without even
+running them!
+
+The type annotation notation has also been backported to earlier
+Python 3.x versions.  Mypy programs are valid Python 3.x and you use a
+normal Python interpreter to run them.  There is essentially no
+performance overhead when using mypy, since mypy does not introduce
+runtime type checking.
+
+You can mix dynamic and static typing in your programs. You can always
+fall back to dynamic typing when static typing is not convenient, such
+as for legacy code.
 
 Here is a small example to whet your appetite:
 
@@ -118,28 +125,20 @@ Development status
 ------------------
 
 Mypy is work in progress and is not yet production quality (though
-mypy development is already done in mypy!).
+mypy development is already done using mypy!).
 
 Here are some of the more significant Python features not supported
 right now (but all of these will improve):
 
- - Python 2.x support not really yet usable
+ - Python 2.x support not usable yet
  - properties with setters not supported
- - somewhat limited operator overloading
+ - limited metaclass support
  - only a subset of Python standard library modules are supported, and some
    only partially
- - limited metaclass support
+ - 3rd party module support is limited
 
-Some mypy-specific features are also not supported or only partially
-supported, including these:
-
- - function overloading does not work properly in all cases, including
-   some instances of method overriding, and keyword arguments
- - no 'Dynamic' classes
- - there is no way to use dynamic typing by default for top-level code
-
-The current development focus is to support static type checking with a good
-subset of Python features (both 2.x and 3.x).
+The current development focus is to have a good coverage of Python
+features and the standard library (initially 3.x, and later 2.7).
 
 
 Issue tracker
@@ -150,6 +149,8 @@ tracker:
 
   https://github.com/JukkaL/mypy/issues
 
+Feel free to also ask questions on the tracker.
+
 
 Help wanted
 -----------

docs/source/class_basics.rst

@@ -21,38 +21,15 @@ initialized within the class. Mypy infers the types of attributes:
 
 This is a bit like each class having an implicitly defined
 ``__slots__`` attribute. In Python semantics this is only enforced
-during type checking: at runtime we use standard Python semantics. You
-can selectively define a class as *dynamic*; dynamic classes have
-Python-like compile-time semantics, and they allow you to assign to
-arbitrary attributes anywhere in a program without the type checker
-complaining:
+during type checking: at runtime we use standard Python semantics.
 
-.. code-block:: python
-
-   from typing import Dynamic
-
-   class A(Dynamic):
-       pass
-
-   a = A()
-   a.x = 2     # OK, no need to define x explicitly.
-
-Mypy also lets you read arbitrary attributes of dynamic class
-instances. This limits type checking effectiveness, so you should only
-use dynamic classes when you really need them.
-
-.. note::
-
-   Dynamic classes are not implemented in the current mypy version.
-
-You can declare variables in the class body explicitly using
-``Undefined`` or a type comment:
+You can declare types of variables in the class body explicitly using
+a type comment:
 
 .. code-block:: python
 
    class A:
-       x = Undefined(List[int])  # Declare attribute x of type List[int]
-       y = 0  # type: Any        # Declare attribute y of type Any
+       x = None  # type: List[int]  # Declare attribute x of type List[int]
 
    a = A()
    a.x = [1]     # OK
@@ -67,10 +44,10 @@ in a method:
 
    class A:
        def __init__(self) -> None:
-           self.x = Undefined(List[int])     # OK
+           self.x = []  # type: List[int]
 
        def f(self) -> None:
-           self.y = 0 # type: Any            # OK
+           self.y = 0  # type: Any
 
 You can only define an instance variable within a method if you assign
 to it explicitly using ``self``:

docs/source/conf.py

@@ -18,7 +18,9 @@
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
+sys.path.insert(0, os.path.abspath('../..'))
+
+from mypy.version import __version__ as mypy_version
 
 # -- General configuration ------------------------------------------------
 
@@ -51,9 +53,9 @@
 # built documents.
 #
 # The short X.Y version.
-version = '0.0.1.dev1'
+version = mypy_version.split('-')[0]
 # The full version, including alpha/beta/rc tags.
-release = '0.0.1.dev1'
+release = mypy_version
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.

docs/source/dynamic_typing.rst

@@ -70,10 +70,10 @@ operations:
         o.foo()       # Error!
         o + 2         # Error!
         open(o)       # Error!
-        n = Undefined(int)
+        n = 1  # type: int
         n = o         # Error!
 
-You can use ``cast()`` (see chapter :ref:`casts`) to go from a general
-type such as ``object`` to a more specific type (subtype) such as
-``int``.  ``cast()`` is not needed with dynamically typed values
-(values with type ``Any``).
+You can use ``cast()`` (see chapter :ref:`casts`) or ``isinstance`` to
+go from a general type such as ``object`` to a more specific
+type (subtype) such as ``int``.  ``cast()`` is not needed with
+dynamically typed values (values with type ``Any``).

docs/source/kinds_of_types.rst

@@ -40,9 +40,10 @@ to a variable with a more precise type:
 
 .. code-block:: python
 
-   a, s = Undefined(Any), Undefined(str)
-   a = 2      # OK
-   s = a      # OK
+   a = None  # type: Any
+   s = ''    # type: str
+   a = 2     # OK
+   s = a     # OK
 
 Declared (and inferred) types are erased at runtime (they are
 basically treated as comments), and thus the above code does not
@@ -220,8 +221,8 @@ string-literal types with non-string-literal types freely:
 
 .. code-block:: python
 
-   a = Undefined(List['A'])  # OK
-   n = Undefined('int')      # OK, though not useful
+   def f(a: List['A']) -> None: ...  # OK
+   def g(n: 'int') -> None: ...      # OK, though not useful
 
    class A: pass
 

docs/source/type_inference_and_annotations.rst

@@ -60,32 +60,23 @@ to ``Any``, which is discussed later.
 Explicit types for variables
 ****************************
 
-.. code-block:: python
-
-   s = Undefined(str)   # Declare type of x to be str.
-   s = 'x'              # OK
-   s = 1                # Type check error
-
-The Undefined call evaluates to a special ``Undefined`` object that
-raises an exception on any operation (except for ``is``, which cannot
-be overloaded):
+You can override the inferred type of a variable by using a
+special type comment after an assignment statement:
 
 .. code-block:: python
 
-   s = Undefined(str)
-   if s:                # Runtime error: undefined value
-       print('hello')
+   x = 1  # type: Union[int, str]
 
-You can also override the inferred type of a variable by using a
-special comment after an assignment statement:
+Without the type comment, the type of ``x`` would be just ``int``. We
+use an annotation to give it a more general type ``Union[int, str]``.
+Mypy checks that the type of the initializer is compatible with the
+declared type. This example is not valid, since the initializer is
+a floating point number, and this is incompatible with the declared
+type:
 
 .. code-block:: python
 
-   x = 1 # type: Union[int, str]
-
-Here the ``# type:`` comment applies both to the assignment target, in
-this case ``x``, and also the initializer expression, via context.
-The type checker infers the value of a variable from the initializer.
+   x = 1.1  # type: Union[int, str]  # Error!
 
 Explicit types for collections
 ******************************
@@ -116,11 +107,10 @@ type separately:
 
 .. code-block:: python
 
-   n, s = Undefined(int), Undefined(str)  # Declare an integer and a string
    i, found = 0, False # type: int, bool
 
-When using the latter form, you can optionally use parentheses around
-the types, assignment targets and assigned expression:
+You can optionally use parentheses around the types, assignment targets
+and assigned expression:
 
 .. code-block:: python
 
@@ -130,7 +120,7 @@ the types, assignment targets and assigned expression:
    (i, found) = (0, False) # type: (int, bool)  # OK
 
 Starred expressions
-******************************
+*******************
 
 In most cases, mypy can infer the type of starred expressions from the
 right-hand side of an assignment, but not always:

lib-python/3.2/posixpath.py

@@ -17,7 +17,7 @@
 from genericpath import *
 
 from typing import (
-    Tuple, BinaryIO, TextIO, Pattern, AnyStr, List, Set, Any, Union, Undefined
+    Tuple, BinaryIO, TextIO, Pattern, AnyStr, List, Set, Any, Union
 )
 
 __all__ = ["normcase","isabs","join","splitdrive","split","splitext",
@@ -249,17 +249,16 @@ def expanduser(path: AnyStr) -> AnyStr:
     i = path.find(sep, 1)
     if i < 0:
         i = len(path)
-    userhome = Undefined(Union[str, bytes])
     if i == 1:
+        userhome = None  # type: Union[str, bytes]
         if 'HOME' not in os.environ:
             import pwd
             userhome = pwd.getpwuid(os.getuid()).pw_dir
         else:
             userhome = os.environ['HOME']
     else:
         import pwd
-        name = Undefined(Union[str, bytes])
-        name = path[1:i]
+        name = path[1:i]  # type: Union[str, bytes]
         if isinstance(name, bytes):
             name = str(name, 'ASCII')
         try:
@@ -311,15 +310,15 @@ def expandvars(path: AnyStr) -> AnyStr:
         if not m:
             break
         i, j = m.span(0)
-        name = Undefined(Union[str, bytes])
+        name = None  # type: Union[str, bytes]
         name = m.group(1)
         if name.startswith(start) and name.endswith(end):
             name = name[1:-1]
         if isinstance(name, bytes):
             name = str(name, 'ASCII')
         if name in os.environ:
             tail = path[j:]
-            value = Undefined(Union[str, bytes])
+            value = None  # type: Union[str, bytes]
             value = os.environ[name]
             if isinstance(path, bytes):
                 value = value.encode('ASCII')

lib-python/3.2/subprocess.py

@@ -348,8 +348,8 @@ class Popen(args, bufsize=0, executable=None,
 import errno
 
 from typing import (
-    Any, Tuple, List, Sequence, Undefined, Callable, Mapping, cast, Set, Dict,
-    IO, TextIO, AnyStr
+    Any, Tuple, List, Sequence, Callable, Mapping, cast, Set, Dict, IO,
+    TextIO, AnyStr
 )
 from types import TracebackType
 

lib-python/3.2/tempfile.py

@@ -38,8 +38,8 @@
 
 from typing import (
     Any as _Any, Callable as _Callable, Iterator as _Iterator,
-    Undefined as _Undefined, List as _List, Tuple as _Tuple, Dict as _Dict,
-    Iterable as _Iterable, IO as _IO, cast as _cast,
+    List as _List, Tuple as _Tuple, Dict as _Dict, Iterable as _Iterable,
+    IO as _IO, cast as _cast,
 )
 from types import TracebackType as _TracebackType
 
@@ -502,7 +502,7 @@ class SpooledTemporaryFile:
     when a fileno is needed.
     """
     _rolled = False
-    _file = _Undefined # type: _Any   # BytesIO, StringIO or TemporaryFile
+    _file = None  # type: _Any   # BytesIO, StringIO or TemporaryFile
 
     def __init__(self, max_size: int = 0, mode: str = 'w+b',
                  buffering: int = -1, encoding: str = None,

lib-python/3.2/test/test_pprint.py

@@ -6,7 +6,7 @@
 import collections
 import itertools
 
-from typing import List, Any, Dict, Tuple, cast, Undefined, Callable
+from typing import List, Any, Dict, Tuple, cast, Callable
 
 # list, tuple and dict subclasses that do or don't overwrite __repr__
 class list2(list):
@@ -457,8 +457,7 @@ def test_sort_unorderable_values(self) -> None:
         keys = [Unorderable() for i in range(n)]
         random.shuffle(keys)
         skeys = sorted(keys, key=id)
-        clean = Undefined(Callable[[str], str])
-        clean = lambda s: s.replace(' ', '').replace('\n','')
+        clean = lambda s: s.replace(' ', '').replace('\n','')  # type: Callable[[str], str]
 
         self.assertEqual(clean(pprint.pformat(set(keys))),
             '{' + ','.join(map(repr, skeys)) + '}')