Disallow type applications

For example,

  x = List[int]()

is no longer supported (to conform to PEP 484). Usually, a '# type:'
comment or a cast can be used instead.

Closes #556.

Author: JukkaL

mypy/checkexpr.py

@@ -988,22 +988,8 @@ def is_valid_cast(self, source_type: Type, target_type: Type) -> bool:
 
     def visit_type_application(self, tapp: TypeApplication) -> Type:
         """Type check a type application (expr[type, ...])."""
-        expr_type = self.accept(tapp.expr)
-        if isinstance(expr_type, CallableType):
-            new_type = self.apply_generic_arguments(expr_type,
-                                                    tapp.types, tapp)
-        elif isinstance(expr_type, Overloaded):
-            overload = expr_type
-            # Only target items with the right number of generic type args.
-            items = [c for c in overload.items()
-                     if len(c.variables) == len(tapp.types)]
-            new_type = self.apply_generic_arguments2(Overloaded(items),
-                                                     tapp.types, tapp)
-        else:
-            self.chk.fail(messages.INVALID_TYPE_APPLICATION_TARGET_TYPE, tapp)
-            new_type = AnyType()
-        self.chk.type_map[tapp.expr] = new_type
-        return new_type
+        self.chk.fail(messages.GENERIC_TYPE_NOT_VALID_AS_EXPRESSION, tapp)
+        return AnyType()
 
     def visit_type_alias_expr(self, alias: TypeAliasExpr) -> Type:
         return AnyType()

mypy/messages.py

@@ -64,6 +64,9 @@
     'Overloaded method has both abstract and non-abstract variants'
 INSTANCE_LAYOUT_CONFLICT = 'Instance layout conflict in multiple inheritance'
 FORMAT_REQUIRES_MAPPING = 'Format requires a mapping'
+GENERIC_TYPE_NOT_VALID_AS_EXPRESSION = \
+    "Generic type not valid as an expression any more (use '# type:' comment instead)"
+
 
 class MessageBuilder:
     """Helper class for reporting type checker error messages with parameters.

mypy/test/data/check-generics.test

@@ -375,99 +375,8 @@ main, line 9: Incompatible types in assignment (expression has type A[A[B]], var
 -- -----------------
 
 
-[case testTrivialTypeApplication]
-from typing import TypeVar
-T = TypeVar('T')
-def f(x: T) -> None: pass
-f[object](None)
-[out]
-
-[case testSimpleGenericFunction]
-from typing import Undefined, TypeVar
-T = TypeVar('T')
-class A: pass
-class B: pass
-a = Undefined # type: A
-b = Undefined # type: B
-
-def id(a: T) -> T:
-    return a
-
-b = id[B](a)  # E: Argument 1 to "id" has incompatible type "A"; expected "B"
-a = id[B](b)  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
-a = id[A](a)
-
-[case testGenericFunctionWithTwoTypeArguments]
-from typing import Undefined, TypeVar, Generic
-S = TypeVar('S')
-T = TypeVar('T')
-
-class t(Generic[S, T]): pass
-class B: pass
-class C: pass
-
-tbc = Undefined # type: t[B, C]
-tbb = Undefined # type: t[B, B]
-b = Undefined # type: B
-c = Undefined # type: C
-
-def f(a: S, b: t[S, T]) -> t[S, T]: pass
-
-tbc = f[B, C](c, tbc) # E: Argument 1 to "f" has incompatible type "C"; expected "B"
-tbc = f[B, C](b, tbb) # E: Argument 2 to "f" has incompatible type t[B, B]; expected t[B, C]
-tbb = f[B, C](b, tbc) # E: Incompatible types in assignment (expression has type t[B, C], variable has type t[B, B])
-tbc = f[B, C](b, tbc)
-
-[case testInvalidNumberOfTypeArgumentsForGenericFunction]
-from typing import Undefined, TypeVar, Generic
-s = TypeVar('s')
-t = TypeVar('t')
-class p(Generic[s, t]): pass
-def f(a: p[s, t]) -> None: pass
-def g() -> None: pass
-a = Undefined # type: p[object, object]
-
-a = f[object](a) # E: Type application has too few types (2 expected)
-a = f[object, object, object](a) # E: Type application has too many types (2 expected)
-g[object]() # E: Type application targets a non-generic function
-f[object, object](a)
-
--- NOTE: Commented out test cases that do not make sense currently.
-
---[case testGenericMethodInNonGenericType]
---from typing import Undefined, TypeVar
---T = TypeVar('T')
---a, b = Undefined, Undefined # type: (A, B)
---class A:
---    def f(self, a: T) -> T: pass
---class B: pass
---
---a = a.f[B](b) # E: Incompatible types in assignment
---a = a.f[A](b) # E: Argument 1 to "f" of "A" has incompatible type "B"
---a = a.f[A](a)
-
---[case testGenericMethodInGenericType]
---from typing import Undefined, TypeVar, Generic
---T = TypeVar('T')
---S = TypeVar('S')
---class A(Generic[T]):
---    def f(self, a: S) -> 'A[t[S, T]]':
---        pass
---class t(Generic[T, S]): pass
---class B: pass
---class C: pass
---ab = Undefined # type: A[B]
---acb = Undefined # type: A[t[C, B]]
---abc = Undefined # type: A[t[B, C]]
---b = Undefined # type: B
---c = Undefined # type: C
---
---abc = ab.f[C](c) # E: Incompatible types in assignment
---acb = ab.f[C](b) # E: Argument 1 to "f" of "A" has incompatible type "B"
---acb = ab.f[C](c)
-
 [case testTypeCheckingGenericFunctionBody]
-from typing import TypeVar, Generic
+from typing import TypeVar, Generic, Undefined
 S = TypeVar('S')
 T = TypeVar('T')
 class A: pass
@@ -476,118 +385,69 @@ class p(Generic[T, S]):
 def f(s: S, t: T) -> p[T, A]:
     a = t # type: S # E: Incompatible types in assignment (expression has type "T", variable has type "S")
     s = t           # E: Incompatible types in assignment (expression has type "T", variable has type "S")
-    return p[S, A](s, A()) # E: Incompatible return value type: expected __main__.p[T`-2, __main__.A], got __main__.p[S`-1, __main__.A*]
+    p_s_a = Undefined(p[S, A])
+    if s:
+        return p_s_a # E: Incompatible return value type: expected __main__.p[T`-2, __main__.A], got __main__.p[S`-1, __main__.A]
     b = t # type: T
     c = s # type: S
-    return p[T, A](t, A())
+    p_t_a = Undefined(p[T, A])
+    return p_t_a
 [out]
 main: In function "f":
 
 [case testTypeCheckingGenericMethodBody]
-from typing import TypeVar, Generic
+from typing import TypeVar, Generic, Undefined
 T = TypeVar('T')
 S = TypeVar('S')
 class p(Generic[T, S]):
     def __init__(self, t: T, a: S) -> None: pass
 class A(Generic[T]):
     def f(self, s: S, t: T) -> p[S, T]:
         s = t # E: Incompatible types in assignment (expression has type "T", variable has type "S")
-        return p[S, S](s, s) # E: Incompatible return value type: expected __main__.p[S`-1, T`1], got __main__.p[S`-1, S`-1]
-        return p[T, T](t, t) # E: Incompatible return value type: expected __main__.p[S`-1, T`1], got __main__.p[T`1, T`1]
+        p_s_s = Undefined(p[S, S])
+        if s:
+            return p_s_s # E: Incompatible return value type: expected __main__.p[S`-1, T`1], got __main__.p[S`-1, S`-1]
+        p_t_t = Undefined(p[T, T])
+        if s:
+            return p_t_t # E: Incompatible return value type: expected __main__.p[S`-1, T`1], got __main__.p[T`1, T`1]
         t = t
         s = s
-        return p[S, T](s, t)
+        p_s_t = Undefined(p[S, T])
+        return p_s_t
 [out]
 main: In member "f" of class "A":
 
 
--- Constructing instances + generics
--- ---------------------------------
+-- Generic types in expressions
+-- ----------------------------
 
 
-[case testConstructingGenericInstanceWithEmptyConstructor]
+[case testInvalidTypeApplicationTarget]
 from typing import TypeVar, Generic
 T = TypeVar('T')
 class A(Generic[T]): pass
-class B: pass
-class C: pass
-a = A[B]() # type: A[C] # Fail
-a = A[B]()              # Fail
-e = A[B]() # type: A[B]
-e = A[B]()
+A[A]() # E: Generic type not valid as an expression any more (use '# type:' comment instead)
+A[int, str]() # E: Generic type not valid as an expression any more (use '# type:' comment instead)
 [out]
-main, line 6: Incompatible types in assignment (expression has type A[B], variable has type A[C])
-main, line 7: Incompatible types in assignment (expression has type A[B], variable has type A[C])
 
-[case testNonEmptyGenericTypeConstructor]
-from typing import Undefined, TypeVar, Generic
+[case testInvalidTypeApplicationTarget2]
+from typing import TypeVar, Generic
 T = TypeVar('T')
-class B: pass
-class C: pass
-class A(Generic[T]):
-    def __init__(self, a: T, b: B) -> None: pass
-ac = Undefined # type: A[C]
-ab = Undefined # type: A[B]
-b = Undefined # type: B
-c = Undefined # type: C
-
-ac = A[C](b, b) # E: Argument 1 to "A" has incompatible type "B"; expected "C"
-ab = A[C](c, b) # E: Incompatible types in assignment (expression has type A[C], variable has type A[B])
-ac = A[C](c, b)
-
-[case testConstructorForGenericTypeWithMultipleArguments]
-from typing import Undefined, TypeVar, Generic
 S = TypeVar('S')
-T = TypeVar('T')
-class A(Generic[S, T]):
-    def __init__(self, t: T, s: S) -> None: pass
-class B: pass
-class C: pass
-
-abc = Undefined # type: A[B, C]
-acb = Undefined # type: A[C, B]
-b, c = Undefined, Undefined # type: (B, C)
-
-abc = A[B, C](b, b) # E: Argument 1 to "A" has incompatible type "B"; expected "C"
-abc = A[B, C](c, c) # E: Argument 2 to "A" has incompatible type "C"; expected "B"
-acb = A[B, C](c, b) # E: Incompatible types in assignment (expression has type A[B, C], variable has type A[C, B])
-abc = A[B, C](c, b)
-acb = A[C, B](b, c)
-
-[case testGenericConstructorOfNonGenericType]
-from typing import Undefined, TypeVar
-T = TypeVar('T')
-class A:
-    def __init__(self, a: T, b: T) -> None: pass
-class B: pass
-class C: pass
-a, b, c = Undefined, Undefined, Undefined # type: (A, B, C)
-
-a = A[B](b, c) # E: Argument 2 to "A" has incompatible type "C"; expected "B"
-a = A[B](c, b) # E: Argument 1 to "A" has incompatible type "C"; expected "B"
-b = A[B](b, b) # E: Incompatible types in assignment (expression has type "A", variable has type "B")
-
-a = A[B](b, b)
-a = A[C](c, c)
+class A(Generic[T, S]): pass
+A[int, str]() # E: Generic type not valid as an expression any more (use '# type:' comment instead)
+A[int]() # E: Generic type not valid as an expression any more (use '# type:' comment instead)
+[out]
 
-[case testInvalidTypeApplicationTarget]
+[case testInvalidTypeApplicationTarget3]
 from typing import Undefined
 a = Undefined # type: A
 class A: pass
 a[A]() # Fail
 A[A]() # Fail
 [out]
 main, line 4: Value of type "A" is not indexable
-main, line 5: Type application targets a non-generic function
-
-[case testInvalidNumberOfGenericArgsInTypeApplication]
-from typing import TypeVar, Generic
-T = TypeVar('T')
-S = TypeVar('S')
-class A(Generic[T, S]): pass
-x = A[int, str, int]() # E: Type application has too many types (2 expected)
-x = A[int]() # E: Type application has too few types (2 expected)
-[out]
+main, line 5: Generic type not valid as an expression any more (use '# type:' comment instead)
 
 
 -- Multiple assignment with lists
@@ -603,20 +463,26 @@ a = Undefined # type: A
 b = Undefined # type: B
 b2 = Undefined # type: B2
 
-a, b = List[A]()   # E: Incompatible types in assignment (expression has type "A", variable has type "B")
-b, a = List[A]()   # E: Incompatible types in assignment (expression has type "A", variable has type "B")
-b2, b2 = List[B]() # E: Incompatible types in assignment (expression has type "B", variable has type "B2")
+list_a = [a]
+list_b = [b]
+list_b2 = [b2]
 
-a, a = List[A]()
-b, b2, b = List[B2]()
+a, b = list_a   # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+b, a = list_a   # E: Incompatible types in assignment (expression has type "A", variable has type "B")
+b2, b2 = list_b # E: Incompatible types in assignment (expression has type "B", variable has type "B2")
+
+a, a = list_a
+b, b2, b = list_b2
 [builtins fixtures/for.py]
 
 [case testMultipleAssignmentWithListsInInitialization]
 from typing import List
 class A: pass
-a, b = List[object]() # type: (A, object) # E: Incompatible types in assignment (expression has type "object", variable has type "A")
-c, d = List[object]() # type: (object, A) # E: Incompatible types in assignment (expression has type "object", variable has type "A")
-e, f = List[A]() # type: (A, object)
+list_object = [object()]
+list_a = [A()]
+a, b = list_object # type: (A, object) # E: Incompatible types in assignment (expression has type "object", variable has type "A")
+c, d = list_object # type: (object, A) # E: Incompatible types in assignment (expression has type "object", variable has type "A")
+e, f = list_a # type: (A, object)
 [builtins fixtures/for.py]
 
 [case testMultipleAssignmentWithListAndIndexing]
@@ -743,22 +609,6 @@ b = f([b])
 b = f(b)
 [builtins fixtures/list.py]
 
-[case testOverloadedGenericFunction]
-from typing import overload, TypeVar, Undefined
-t = TypeVar('t')
-class A: pass
-class B: pass
-
-@overload
-def f(x: int, a: A) -> A: pass
-@overload
-def f(x: str, a: t) -> t: pass
-
-a, b = Undefined, Undefined # type: (A, B)
-b = f[B]('', b)
-a = f[B]('', b) # E: Incompatible types in assignment (expression has type "B", variable has type "A")
-f[B](1, a) # E: No overload variant of "f" matches argument types
-
 
 -- Type variable scoping
 -- ---------------------

mypy/test/data/check-inference-context.test

@@ -453,8 +453,10 @@ t = TypeVar('t')
 class A(Generic[t]): pass
 class B: pass
 class C: pass
-d = {A()    : A[C](),
-     A[B]() : A()} # type: Dict[A[B], A[C]]
+a_b = A() # type: A[B]
+a_c = A() # type: A[C]
+d = {A() : a_c,
+     a_b : A()} # type: Dict[A[B], A[C]]
 [builtins fixtures/dict.py]
 
 
@@ -504,7 +506,8 @@ from typing import TypeVar, Generic
 from abc import abstractmethod, ABCMeta
 t = TypeVar('t')
 x = A() # type: I[int]
-y = A[object]() # type: I[int] # E: Incompatible types in assignment (expression has type A[object], variable has type I[int])
+a_object = A() # type: A[object]
+y = a_object # type: I[int] # E: Incompatible types in assignment (expression has type A[object], variable has type I[int])
 
 class I(Generic[t]):
     @abstractmethod
@@ -517,7 +520,8 @@ from typing import TypeVar, Generic
 from abc import abstractmethod, ABCMeta
 t = TypeVar('t')
 a = f(A()) # type: A[int]
-aa = f(A[int]())
+a_int = A() # type: A[int]
+aa = f(a_int)
 class I(Generic[t]): pass
 class A(I[t], Generic[t]): pass
 def f(i: I[t]) -> A[t]: pass
@@ -529,19 +533,7 @@ class set(Generic[t]):
     def __init__(self, iterable: Iterable[t]) -> None: pass
 b = bool()
 l = set([b])
-l = set[bool]([])
-l = set[object]([]) # E: Incompatible types in assignment (expression has type set[object], variable has type set[bool])
-[builtins fixtures/for.py]
-
-[case testInferenceWithAbstractClassContext4]
-from typing import TypeVar, Generic, Iterable
-t = TypeVar('t')
-class set(Generic[t]): pass
-def f(iterable: Iterable[t]) -> set[t]: pass
-b = bool()
-l = f([b])
-l = f[bool]([])
-l = f[object]([]) # E: Incompatible types in assignment (expression has type set[object], variable has type set[bool])
+l = set([object()]) # E: List item 1 has incompatible type "object"
 [builtins fixtures/for.py]