Merge branch 'master' into generic-classmethod-type

Author: kitsuyui

.travis.yml

@@ -1,21 +1,46 @@
-sudo: false
+if: tag IS present OR type = pull_request OR (branch = master AND type = push)   # we only CI the master, tags and PRs
+
 language: python
 # cache package wheels (1 cache per python version)
 cache: pip
-python:
-  - "3.4"
+# newer python versions are available only on xenial (while some older only on trusty) Ubuntu distribution
+dist: xenial
+sudo: required
+
+env:
+  TOXENV=py
+  EXTRA_ARGS="-n 12"
+
+jobs:
+  include:
+  - name: "run test suite with python 3.4"
+    python: 3.4
+    dist: trusty
   # Specifically request 3.5.1 because we need to be compatible with that.
-  - "3.5.1"
-  - "3.6"
-  - "3.7-dev"
+  - name: "run test suite with python 3.5.1"
+    python: 3.5.1
+    dist: trusty
+  - name: "run test suite with python 3.6"
+    python: 3.6    # 3.6.3  pip  9.0.1
+  - name: "run test suite with python 3.7"
+    python: 3.7    # 3.7.0  pip 10.0.1
+  - name: "run test suite with python 3.8-dev"
+    python: 3.8-dev
+  - name: "type check our own code"
+    python: 3.7
+    env:
+    - TOXENV=type
+    - EXTRA_ARGS=
+  - name: "check code style with flake8"
+    python: 3.7
+    env:
+    - TOXENV=lint
+    - EXTRA_ARGS=
 
 install:
-  - pip install -U pip setuptools wheel
-  - pip install -r test-requirements.txt
-  - python2 -m pip install --user typing
-  - pip install .
+- pip install -U pip setuptools
+- pip install -U tox
+- tox --notest
 
 script:
-  - pytest -n12
-  - if [[ $TRAVIS_PYTHON_VERSION == '3.6' ]]; then flake8 -j12; fi
-  - if [[ $TRAVIS_PYTHON_VERSION == '3.5.1' ]]; then python3 -m mypy --config-file mypy_self_check.ini -p mypy; fi
+- tox -- $EXTRA_ARGS

appveyor.yml

@@ -4,24 +4,22 @@ cache:
 environment:
   matrix:
 
-    - PYTHON: "C:\\Python36-x64"
-      PYTHON_VERSION: "3.6.x"
+    - PYTHON: "C:\\Python37-x64"
+      PYTHON_VERSION: "3.7.x"
       PYTHON_ARCH: "64"
 
 install:
     - "git config core.symlinks true"
     - "git reset --hard"
-    - "%PYTHON%\\python.exe -m pip install -r test-requirements.txt"
-    - "C:\\Python27\\python.exe -m pip install typing"
     - "git submodule update --init typeshed"
     - "cd typeshed && git config core.symlinks true && git reset --hard && cd .."
-    - "%PYTHON%\\python.exe -m pip install ."
+    - "%PYTHON%\\python.exe -m pip install -U setuptools tox"
+    - "%PYTHON%\\python.exe -m tox -e py37 --notest"
 
 build: off
 
 test_script:
-    # lint and mypy self check run in Travis
-    - "%PYTHON%\\python.exe -m pytest -k \"not (PythonEvaluationSuite and python2)\""
+    - "%PYTHON%\\python.exe -m tox -e py37"
 
 skip_commits:
   files:

docs/source/builtin_types.rst

@@ -35,6 +35,6 @@ strings and and ``Dict[Any, Any]`` is a dictionary of dynamically typed
 correspond to Python protocols. For example, a ``str`` object or a
 ``List[str]`` object is valid
 when ``Iterable[str]`` or ``Sequence[str]`` is expected. Note that even though
-they are similar to abstract base classes defined in ``abc.collections``
+they are similar to abstract base classes defined in ``collections.abc``
 (formerly ``collections``), they are not identical, since the built-in
 collection type objects do not support indexing.

docs/source/command_line.rst

@@ -273,7 +273,7 @@ For more details, see :ref:`no_strict_optional`.
 
     For example, by default mypy will assume that the ``x`` parameter
     is of type ``Optional[int]`` in the code snippet below since
-    the default pararameter is ``None``:
+    the default parameter is ``None``:
 
     .. code-block:: python
 

docs/source/generics.rst

@@ -653,6 +653,8 @@ Generic protocols can also be recursive. Example:
 
    result = last(L())  # Inferred type of 'result' is 'int'
 
+.. _generic-type-aliases:
+
 Generic type aliases
 ********************
 

docs/source/kinds_of_types.rst

@@ -186,6 +186,8 @@ Any)`` function signature. Example:
     arbitrary_call(open)  # Error: does not return an int
     arbitrary_call(1)     # Error: 'int' is not callable
 
+In situations where more precise or complex types of callbacks are
+necessary one can use flexible :ref:`callback protocols <callback_protocols>`.
 Lambdas are also supported. The lambda argument and return value types
 cannot be given explicitly; they are always inferred based on context
 using bidirectional type inference:
@@ -546,7 +548,8 @@ assigning the type to a variable:
 .. note::
 
     A type alias does not create a new type. It's just a shorthand notation for
-    another type -- it's equivalent to the target type.
+    another type -- it's equivalent to the target type except for
+    :ref:`generic aliases <generic-type-aliases>`.
 
 .. _named-tuples:
 

docs/source/protocols.rst

@@ -409,3 +409,54 @@ in ``typing`` such as ``Iterable``.
    ``isinstance()`` with protocols is not completely safe at runtime.
    For example, signatures of methods are not checked. The runtime
    implementation only checks that all protocol members are defined.
+
+.. _callback_protocols:
+
+Callback protocols
+******************
+
+Protocols can be used to define flexible callback types that are hard
+(or even impossible) to express using the ``Callable[...]`` syntax, such as variadic,
+overloaded, and complex generic callbacks. They are defined with a special ``__call__``
+member:
+
+.. code-block:: python
+
+   from typing import Optional, Iterable, List
+   from typing_extensions import Protocol
+
+   class Combiner(Protocol):
+       def __call__(self, *vals: bytes, maxlen: Optional[int] = None) -> List[bytes]: ...
+
+   def batch_proc(data: Iterable[bytes], cb_results: Combiner) -> bytes:
+       for item in data:
+           ...
+
+   def good_cb(*vals: bytes, maxlen: Optional[int] = None) -> List[bytes]:
+       ...
+   def bad_cb(*vals: bytes, maxitems: Optional[int]) -> List[bytes]:
+       ...
+
+   batch_proc([], good_cb)  # OK
+   batch_proc([], bad_cb)   # Error! Argument 2 has incompatible type because of
+                            # different name and kind in the callback
+
+Callback protocols and ``Callable[...]`` types can be used interchangeably.
+Keyword argument names in ``__call__`` methods must be identical, unless
+a double underscore prefix is used. For example:
+
+.. code-block:: python
+
+   from typing import Callable, TypeVar
+   from typing_extensions import Protocol
+
+   T = TypeVar('T')
+
+   class Copy(Protocol):
+       def __call__(self, __origin: T) -> T: ...
+
+   copy_a: Callable[[T], T]
+   copy_b: Copy
+
+   copy_a = copy_b  # OK
+   copy_b = copy_a  # Also OK

docs/source/running_mypy.rst

@@ -131,7 +131,7 @@ Missing imports
 When you import a module, mypy may report that it is unable to
 follow the import.
 
-This could happen if the code is importing a non-existant module
+This could happen if the code is importing a non-existent module
 or if the code is importing a library that does not use type hints.
 Specifically, the library is neither declared to be a 
 :ref:`PEP 561 compliant package <installed-packages>` nor has registered

extensions/mypy_extensions.py

@@ -139,3 +139,21 @@ class NoReturn: pass
 
 def trait(cls):
     return cls
+
+
+# TODO: We may want to try to properly apply this to any type
+# variables left over...
+class _FlexibleAliasClsApplied:
+    def __init__(self, val):
+        self.val = val
+
+    def __getitem__(self, args):
+        return self.val
+
+
+class _FlexibleAliasCls:
+    def __getitem__(self, args):
+        return _FlexibleAliasClsApplied(args[-1])
+
+
+FlexibleAlias = _FlexibleAliasCls()

extensions/setup.py

@@ -2,7 +2,7 @@
 
 from setuptools import setup
 
-version = '0.4.0-dev'
+version = '0.5.0-dev'
 description = 'Experimental type system extensions for programs checked with the mypy typechecker.'
 long_description = '''
 Mypy Extensions

mypy/bogus_type.py

@@ -0,0 +1,22 @@
+"""A Bogus[T] type alias for marking when we subvert the type system
+
+We need this for compiling with mypyc, which inserts runtime
+typechecks that cause problems when we subvert the type system. So
+when compiling with mypyc, we turn those places into Any, while
+keeping the types around for normal typechecks.
+
+Since this causes the runtime types to be Any, this is best used
+in places where efficient access to properties is not important.
+For those cases some other technique should be used.
+"""
+
+from mypy_extensions import FlexibleAlias
+from typing import TypeVar, Any
+
+T = TypeVar('T')
+
+SUPPRESS_BOGUS_TYPES = False
+if SUPPRESS_BOGUS_TYPES:
+    Bogus = FlexibleAlias[T, Any]
+else:
+    Bogus = FlexibleAlias[T, T]