Merge branch 'new-typevar-syntax'

Closes #539.

Author: JukkaL

docs/source/generics.rst

@@ -151,7 +151,7 @@ as its value. A typical example is a type variable that can only have values
 
    from typing import TypeVar
 
-   AnyStr = TypeVar('AnyStr', values=(str, bytes))
+   AnyStr = TypeVar('AnyStr', str, bytes)
 
 This is actually such a common type variable that ``AnyStr`` is
 defined in ``typing`` and we don't need to define it ourselves.
@@ -209,7 +209,7 @@ this is correct for ``concat``, since ``concat`` actually returns a
     >>> print(type(ss))
     <class 'str'>
 
-You can also use a ``TypeVar`` with ``values`` when defining a generic
-class. For example, mypy uses the type ``typing.Pattern[AnyStr]`` for the
-return value of ``re.compile``, since regular expressions can be based
-on a string or a bytes pattern.
+You can also use a ``TypeVar`` with a restricted set of possible
+values when defining a generic class. For example, mypy uses the type
+``typing.Pattern[AnyStr]`` for the return value of ``re.compile``,
+since regular expressions can be based on a string or a bytes pattern.

lib-python/3.2/test/test_random.py

@@ -10,7 +10,7 @@
 
 from typing import Undefined, Any, Dict, List, Callable, Generic, TypeVar
 
-RT = TypeVar('RT', values=(random.Random, random.SystemRandom))
+RT = TypeVar('RT', random.Random, random.SystemRandom)
 
 class TestBasicOps(unittest.TestCase, Generic[RT]):
     # Superclass with tests common to all generators.

lib-typing/2.7/test_typing.py

@@ -73,7 +73,7 @@ def test_typevar(self):
         self.assertIsNone(t.values)
 
     def test_typevar_values(self):
-        t = TypeVar('t', values=(int, unicode))
+        t = TypeVar('t', int, unicode)
         self.assertEqual(t.name, 't')
         self.assertEqual(t.values, (int, unicode))
 

lib-typing/2.7/typing.py

@@ -183,13 +183,15 @@ def NamedTuple(typename, fields):
 
 
 class TypeVar(object):
-    def __init__(self, name, values=None):
+    def __init__(self, name, *values):
         self.name = name
+        if not values:
+            values = None
         self.values = values
 
 
 # Predefined type variables.
-AnyStr = TypeVar('AnyStr', values=(str, unicode))
+AnyStr = TypeVar('AnyStr', str, unicode)
 
 
 class forwardref(object):

lib-typing/3.2/test_typing.py

@@ -71,7 +71,7 @@ def test_typevar(self):
         self.assertIsNone(t.values)
 
     def test_typevar_values(self):
-        t = TypeVar('t', values=(int, str))
+        t = TypeVar('t', int, str)
         self.assertEqual(t.name, 't')
         self.assertEqual(t.values, (int, str))
 

lib-typing/3.2/typing.py

@@ -183,13 +183,15 @@ def NamedTuple(typename, fields):
 
 
 class TypeVar:
-    def __init__(self, name, *, values=None):
+    def __init__(self, name, *values):
         self.name = name
+        if not values:
+            values = None
         self.values = values
 
 
 # Predefined type variables.
-AnyStr = TypeVar('AnyStr', values=(str, bytes))
+AnyStr = TypeVar('AnyStr', str, bytes)
 
 
 class forwardref:

mypy/semanal.py

@@ -968,11 +968,14 @@ def process_typevar_declaration(self, s: AssignmentStmt) -> None:
         if len(call.args) < 1:
             self.fail("Too few arguments for TypeVar()", s)
             return
-        if len(call.args) > 2:
-            self.fail("Too many arguments for TypeVar()", s)
-            return
-        if call.arg_kinds not in ([ARG_POS], [ARG_POS, ARG_NAMED]):
-            self.fail("Unexpected arguments to TypeVar()", s)
+        if call.arg_kinds != [ARG_POS] * len(call.arg_kinds):
+            if call.arg_kinds == [ARG_POS, ARG_NAMED] and call.arg_names[1] == 'values':
+                # Probably using obsolete syntax with values=(...). Explain the current syntax.
+                self.fail("TypeVar 'values' argument not supported", s)
+                self.fail("Use TypeVar('T', t, ...) instead of TypeVar('T', values=(t, ...))",
+                          s)
+            else:
+                self.fail("Unexpected arguments to TypeVar()", s)
             return
         if not isinstance(call.args[0], StrExpr):
             self.fail("TypeVar() expects a string literal argument", s)
@@ -988,19 +991,11 @@ def process_typevar_declaration(self, s: AssignmentStmt) -> None:
             else:
                 self.fail("Cannot redefine '%s' as a type variable" % name, s)
             return
-        if len(call.args) == 2:
-            # Analyze values=(...) argument.
-            if call.arg_names[1] != 'values':
-                self.fail("Unexpected keyword argument '{}' to TypeVar()".
-                          format(call.arg_names[1]), s)
-                return
-            expr = call.args[1]
-            if isinstance(expr, TupleExpr):
-                values = self.analyze_types(expr.items)
-            else:
-                self.fail('The values argument must be a tuple literal', s)
-                return
+        if len(call.args) > 1:
+            # Analyze enumeration of type variable values.
+            values = self.analyze_types(call.args[1:])
         else:
+            # Type variables can refer to an arbitrary type.
             values = []
         # Yes, it's a valid type variable definition! Add it to the symbol table.
         node = self.lookup(name, s)

mypy/test/data/check-generics.test

@@ -793,7 +793,7 @@ a = '' # E: Incompatible types in assignment (expression has type "str", variabl
 
 [case testSubtypingWithGenericFunctionUsingTypevarWithValues]
 from typing import TypeVar, Callable
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T: pass
 def g1(f: Callable[[str], str]) -> None: pass
 g1(f)

mypy/test/data/check-typevar-values.test

@@ -3,15 +3,15 @@
 
 [case testCallGenericFunctionWithTypeVarValueRestriction]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None: pass
 f(1)
 f('x')
 f(object()) # E: Type argument 1 of "f" has incompatible value "object"
 
 [case testCallGenericFunctionWithTypeVarValueRestrictionUsingContext]
 from typing import TypeVar, List
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> List[T]: pass
 i = [1]
 s = ['x']
@@ -23,22 +23,22 @@ o = f(1) # E: Type argument 1 of "f" has incompatible value "object"
 
 [case testCallGenericFunctionWithTypeVarValueRestrictionAndAnyArgs]
 from typing import TypeVar, Any
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None: pass
 f(Any(object()))
 [out]
 
 [case testCallGenericFunctionWithTypeVarValueRestrictionInDynamicFunc]
 from typing import TypeVar, Any
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None: pass
 def g():
     f(object())
 [out]
 
 [case testCallGenericFunctionWithTypeVarValueRestrictionUsingSubtype]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None: pass
 class S(str): pass
 f(S())
@@ -50,7 +50,7 @@ class A:
     def f(self, x: int) -> A: return self
 class B:
     def f(self, x: int) -> B: return self
-AB = TypeVar('AB', values=(A, B))
+AB = TypeVar('AB', A, B)
 def f(x: AB) -> AB:
     x = x.f(1)
     return x.f(1)
@@ -63,7 +63,7 @@ class A:
 class B:
     def f(self) -> A: return A()
     def g(self) -> B: return B()
-AB = TypeVar('AB', values=(A, B))
+AB = TypeVar('AB', A, B)
 def f(x: AB) -> AB:
     return x.f() # Error
 def g(x: AB) -> AB:
@@ -82,7 +82,7 @@ class A:
 class B:
     def f(self) -> B: return self
     def g(self) -> B: return B()
-AB = TypeVar('AB', values=(A, B))
+AB = TypeVar('AB', A, B)
 def f(x: AB) -> AB:
     y = x
     if y:
@@ -94,7 +94,7 @@ main: In function "f":
 
 [case testTypeApplicationAndTypeVarValues]
 from typing import TypeVar, List
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> List[T]:
     return List[T]()
 def g(x: T) -> List[T]:
@@ -105,7 +105,7 @@ main: In function "g":
 
 [case testTypeDeclaredBasedOnTypeVarWithValues]
 from typing import TypeVar, Undefined
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     a = Undefined(T)
     b = None # type: T
@@ -118,7 +118,7 @@ main: In function "f":
 
 [case testIsinstanceAndTypeVarValues]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
         return 2
@@ -135,7 +135,7 @@ main: In function "h":
 
 [case testIsinstanceAndTypeVarValues2]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
         return 2
@@ -153,7 +153,7 @@ main: In function "g":
 
 [case testIsinstanceAndTypeVarValues3]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
         y = 1
@@ -164,7 +164,7 @@ def f(x: T) -> T:
 
 [case testIsinstanceAndTypeVarValues4]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
         y = 1
@@ -177,7 +177,7 @@ main: In function "f":
 
 [case testIsinstanceAndTypeVarValues5]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T:
     if isinstance(x, int):
         y = object()
@@ -192,7 +192,7 @@ main: In function "f":
 from typing import TypeVar, Undefined
 class A: pass
 class B: pass
-T = TypeVar('T', values=(A, B))
+T = TypeVar('T', A, B)
 def f(x: T) -> None:
     y = x
     if isinstance(x, A):
@@ -204,7 +204,7 @@ def f(x: T) -> None:
         x = B()
         x = y
         x.foo() # E: "B" has no attribute "foo"
-S = TypeVar('S', values=(int, str))
+S = TypeVar('S', int, str)
 def g(x: S) -> None:
     y = x
     if isinstance(x, int):
@@ -216,7 +216,7 @@ main: In function "f":
 [case testIsinstanceWithUserDefinedTypeAndTypeVarValues2]
 from typing import TypeVar, Undefined
 class S(str): pass
-T = TypeVar('T', values=(S, int))
+T = TypeVar('T', S, int)
 def f(x: T) -> None:
     y = x
     if isinstance(x, S):
@@ -234,7 +234,7 @@ main: In function "f":
 
 [case testTypeVarValuesAndNestedCalls]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(m: T) -> int: pass
 def h(x: int) -> int: pass
 def g(a: T) -> None:
@@ -243,7 +243,7 @@ def g(a: T) -> None:
 
 [case testGenericTypeWithTypevarValues]
 from typing import TypeVar, Generic, Undefined, Any
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class A(Generic[X]): pass
 a = Undefined(A[int])
 b = Undefined(A[str])
@@ -252,7 +252,7 @@ c = Undefined(A[Any])
 
 [case testGenericTypeWithTypevarValuesAndTypeApplication]
 from typing import TypeVar, Generic, Undefined, Any
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class A(Generic[X]): pass
 A[int]()
 A[str]()
@@ -261,7 +261,7 @@ A[object]() # E: Type argument 1 of "A" has incompatible value "object"
 
 [case testConstructGenericTypeWithTypevarValuesAndTypeInference]
 from typing import TypeVar, Generic, Any
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class A(Generic[X]):
     def __init__(self, x: X) -> None: pass
 A(1)
@@ -272,8 +272,8 @@ A(object()) # E: Type argument 1 of "A" has incompatible value "object"
 [case testGenericTypeWithTypevarValuesAndTypevarArgument]
 from typing import TypeVar, Generic, Undefined
 class C: pass
-X = TypeVar('X', values=(int, str))
-Y = TypeVar('Y', values=(int, C))
+X = TypeVar('X', int, str)
+Y = TypeVar('Y', int, C)
 Z = TypeVar('Z')
 class D(Generic[X]):
     def __init__(self, x: X) -> None: pass
@@ -291,7 +291,7 @@ main, line 13: Type variable "Z" not valid as type argument value for "D"
 
 [case testGenericTypeWithTypevarValuesAndSubtypePromotion]
 from typing import TypeVar, Generic, Undefined
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class S(str): pass
 class C(Generic[X]):
     def __init__(self, x: X) -> None: pass
@@ -311,7 +311,7 @@ class B:
     def f(self, x: int) -> None: pass
     def g(self, x: str) -> None: pass
     def h(self, x: int) -> None: pass
-X = TypeVar('X', values=(A, B))
+X = TypeVar('X', A, B)
 class C(Generic[X]):
     def f(self, x: X) -> None:
         x.f(1)
@@ -322,7 +322,7 @@ main: In member "f" of class "C":
 
 [case testAttributeInGenericTypeWithTypevarValues1]
 from typing import TypeVar, Generic, Undefined
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class C(Generic[X]):
     x = Undefined(X)
     def f(self, x: X) -> None:
@@ -333,7 +333,7 @@ main: In member "f" of class "C":
 
 [case testAttributeInGenericTypeWithTypevarValues2]
 from typing import TypeVar, Generic, Undefined
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class C(Generic[X]):
     x = Undefined(X)
 cn = C[int]()
@@ -345,7 +345,7 @@ cs.x = 1 # E: Incompatible types in assignment (expression has type "int", varia
 
 [case testInferredAttributeInGenericClassBodyWithTypevarValues]
 from typing import TypeVar, Generic, Undefined
-X = TypeVar('X', values=(int, str))
+X = TypeVar('X', int, str)
 class C(Generic[X]):
     x = 1
 C.x = 1
@@ -357,8 +357,8 @@ class A:
     def f(self, x: int) -> None: pass
 class B:
     def f(self, x: str) -> None: pass
-X = TypeVar('X', values=(A, B))
-Y = TypeVar('Y', values=(int, str))
+X = TypeVar('X', A, B)
+Y = TypeVar('Y', int, str)
 class C(Generic[X, Y]):
     def f(self, x: X, y: Y) -> None:
         x.f(y)
@@ -371,8 +371,8 @@ main, line 10: Argument 1 to "f" of "B" has incompatible type "int"; expected "s
 from typing import TypeVar, Generic, Undefined
 class A: pass
 class B: pass
-X = TypeVar('X', values=(A, B))
-Y = TypeVar('Y', values=(int, str))
+X = TypeVar('X', A, B)
+Y = TypeVar('Y', int, str)
 class C(Generic[X, Y]): pass
 a = Undefined(C[A, int])
 b = Undefined(C[B, str])
@@ -383,8 +383,8 @@ c = Undefined(C[A, A])     # E: Invalid type argument value for "C"
 from typing import TypeVar
 class A: pass
 class B: pass
-X = TypeVar('X', values=(A, B))
-Y = TypeVar('Y', values=(int, str))
+X = TypeVar('X', A, B)
+Y = TypeVar('Y', int, str)
 def f(x: X, y: Y) -> None: pass
 f(A(), '')
 f(B(), 1)
@@ -394,7 +394,7 @@ f(1, 1) # E: Type argument 1 of "f" has incompatible value "int"
 [case testGenericFunctionWithNormalAndRestrictedTypevar]
 from typing import TypeVar, Generic, Undefined
 X = TypeVar('X')
-Y = TypeVar('Y', values=(int, str))
+Y = TypeVar('Y', int, str)
 class C(Generic[Y]):
     def __init__(self, y: Y) -> None: pass
 def f(x: X, y: Y, z: int) -> None:
@@ -413,7 +413,7 @@ main, line 11: "str" has no attribute "foo"
 
 [case testTypeVarWithValueInferredFromObjectReturnTypeContext]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def c1(x: object) -> None: pass
 def c2(x: int) -> None: pass
 def c3(x: str) -> None: pass
@@ -426,7 +426,7 @@ c3(g(1))   # E: Argument 1 to "c3" has incompatible type "int"; expected "str"
 
 [case testTypeVarWithValueInferredFromObjectReturnTypeContext2]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 class ss(str): pass
 def c(x: ss) -> None: pass
 def g(x: T) -> T: pass
@@ -444,7 +444,7 @@ main, line 7: Argument 1 to "c" has incompatible type "int"; expected "ss"
 [case testTypevarValuesSpecialCase1]
 from typing import TypeVar, Generic
 from abc import abstractmethod
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 class A(Generic[T]):
     @abstractmethod
     def f(self) -> 'A[T]': pass
@@ -460,14 +460,14 @@ main: In class "C":
 
 [case testDefaultArgumentValueInGenericClassWithTypevarValues]
 from typing import TypeVar, Generic
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 class C(Generic[T]):
     def f(self, x: int = None) -> None: pass
 
 [case testTypevarValuesWithOverloadedFunctionSpecialCase]
 from typing import TypeVar, overload, Callable
 
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None:
      y = m(g, x)
      x = y

mypy/test/data/pythoneval.test

@@ -337,7 +337,7 @@ if isinstance(x, tuple):
 
 [case testTypevarValues]
 from typing import TypeVar
-T = TypeVar('T', values=(str, bytes))
+T = TypeVar('T', str, bytes)
 def f(x: T) -> T:
     if isinstance(x, str):
         return 'foo'
@@ -425,8 +425,8 @@ b'xx'
 [case testMultipleTypevarsWithValues]
 from typing import TypeVar
 
-T = TypeVar('T', values=(int, str))
-S = TypeVar('S', values=(int, str))
+T = TypeVar('T', int, str)
+S = TypeVar('S', int, str)
 
 def f(t: T, s: S) -> None:
     t + s

mypy/test/data/semanal-errors.test

@@ -1082,18 +1082,24 @@ a = TypeVar()       # E: Too few arguments for TypeVar()
 b = TypeVar(x='b')  # E: Unexpected arguments to TypeVar()
 c = TypeVar(1)      # E: TypeVar() expects a string literal argument
 d = TypeVar('D')    # E: Unexpected TypeVar() argument value
-e = TypeVar('e', values=(int, str), x=1) # E: Too many arguments for TypeVar()
-f = TypeVar('f', (int, str)) # E: Unexpected arguments to TypeVar()
-g = TypeVar('g', x=(int, str)) # E: Unexpected keyword argument 'x' to TypeVar()
+e = TypeVar('e', int, str, x=1) # E: Unexpected arguments to TypeVar()
+f = TypeVar('f', (int, str)) # E: Type expected
+g = TypeVar('g', x=(int, str)) # E: Unexpected arguments to TypeVar()
 [out]
 
 [case testInvalidTypevarValues]
 from typing import TypeVar
-a = TypeVar('a', values=int) # E: The values argument must be a tuple literal
-b = TypeVar('b', values=(int)) # E: The values argument must be a tuple literal
-c = TypeVar('c', values=(int, 2)) # E: Type expected
+b = TypeVar('b', *[int]) # E: Unexpected arguments to TypeVar()
+c = TypeVar('c', int, 2) # E: Type expected
 [out]
 
+[case testObsoleteTypevarValuesSyntax]
+from typing import TypeVar
+a = TypeVar('a', values=(int, str))
+[out]
+main, line 2: TypeVar 'values' argument not supported
+main, line 2: Use TypeVar('T', t, ...) instead of TypeVar('T', values=(t, ...))
+
 [case testLocalTypevarScope]
 from typing import TypeVar
 def f() -> None:

mypy/test/data/semanal-types.test

@@ -1293,8 +1293,8 @@ MypyFile:1(
 
 [case testTypevarWithValues]
 from typing import TypeVar, Any
-T = TypeVar('T', values=(int, str))
-S = TypeVar('S', values=(Any, int, str))
+T = TypeVar('T', int, str)
+S = TypeVar('S', Any, int, str)
 [out]
 MypyFile:1(
   ImportFrom:1(typing, [TypeVar : TypeVar, Any : Any])
@@ -1314,7 +1314,7 @@ MypyFile:1(
 
 [case testGenericFunctionWithValueSet]
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T: pass
 [out]
 MypyFile:1(
@@ -1335,7 +1335,7 @@ MypyFile:1(
 
 [case testGenericClassWithValueSet]
 from typing import TypeVar, Generic
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 class C(Generic[T]): pass
 [out]
 MypyFile:1(

mypy/test/data/typexport-basic.test

@@ -1033,7 +1033,7 @@ MemberExpr(10) : def [1:B, -1:builtins.object] (self: A[B], y: builtins.object)
 [case testTypeVariableWithValueRestriction]
 ## NameExpr
 from typing import TypeVar
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> None: pass
 f(1)
 f('x')
@@ -1044,7 +1044,7 @@ NameExpr(6) : def [-1:builtins.str] (x: builtins.str)
 [case testTypeVariableWithValueRestrictionAndSubtype]
 ## NameExpr|CallExpr
 from typing import TypeVar, Undefined
-T = TypeVar('T', values=(int, str))
+T = TypeVar('T', int, str)
 def f(x: T) -> T: pass
 class S(str): pass
 s = Undefined # type: S

stubs/2.7/typing.py

@@ -32,7 +32,7 @@ def __getitem__(self, typeargs): pass
 Set = TypeAlias(object)
 
 # Predefined type variables.
-AnyStr = TypeVar('AnyStr', values=(str, unicode))
+AnyStr = TypeVar('AnyStr', str, unicode)
 
 # Abstract base classes.
 

stubs/3.2/builtins.py

@@ -636,7 +636,7 @@ def callable(o: object) -> bool: pass
 def chr(code: int) -> str: pass
 def delattr(o: Any, name: str) -> None: pass
 def dir(o: object = None) -> List[str]: pass
-_N = TypeVar('_N', values=(int, float))
+_N = TypeVar('_N', int, float)
 def divmod(a: _N, b: _N) -> Tuple[_N, _N]: pass
 def eval(source: str, globals: Dict[str, Any] = None,
          locals: Mapping[str, Any] = None) -> Any: pass  # TODO code object as source

stubs/3.2/typing.py

@@ -32,7 +32,7 @@ def __getitem__(self, typeargs): pass
 Set = TypeAlias(object)
 
 # Predefined type variables.
-AnyStr = TypeVar('AnyStr', values=(str, bytes))
+AnyStr = TypeVar('AnyStr', str, bytes)
 
 # Abstract base classes.