Updates based on review

python · ilevkivskyi · Jul 8, 2019 · Jul 6, 2019 · Jul 6, 2019 · Jul 6, 2019
commit f3cf9f2e6d38747e23f2bcbf6ed05deaae9b0d02
diff --git a/mypy/newsemanal/semanal.py b/mypy/newsemanal/semanal.py
@@ -1383,12 +1383,13 @@ def analyze_base_classes(
             try:
                 base = self.expr_to_analyzed_type(base_expr, allow_placeholder=True)
             except TypeTranslationError:
-                msg = 'Invalid base class'
                 name = self.get_name_repr_of_expr(base_expr)
+                if isinstance(base_expr, CallExpr):
+                    msg = 'Unsupported dynamic base class'
+                else:
+                    msg = 'Invalid base class'
                 if name:
                     msg += ' "{}"'.format(name)
-                if isinstance(base_expr, CallExpr):
-                    msg += ': Unsupported dynamic base class'
                 self.fail(msg, base_expr)
                 is_error = True
                 continue
@@ -3208,7 +3209,7 @@ def visit_with_stmt(self, s: WithStmt) -> None:
             actual_targets = [t for t in s.target if t is not None]
             if len(actual_targets) == 0:
                 # We have a type for no targets
-                self.fail('Invalid type comment: `with` statement has no targets', s)
+                self.fail('Invalid type comment: "with" statement has no targets', s)
             elif len(actual_targets) == 1:
                 # We have one target and one type
                 types = [s.unanalyzed_type]
@@ -3218,10 +3219,10 @@ def visit_with_stmt(self, s: WithStmt) -> None:
                     types = s.unanalyzed_type.items.copy()
                 else:
                     # But it's the wrong number of items
-                    self.fail('Incompatible number of types for `with` targets', s)
+                    self.fail('Incompatible number of types for "with" targets', s)
             else:
                 # We have multiple targets and one type
-                self.fail('Multiple types expected for multiple `with` targets', s)
+                self.fail('Multiple types expected for multiple "with" targets', s)
 
         new_types = []  # type: List[Type]
         for e, n in zip(s.expr, s.target):

diff --git a/mypy/newsemanal/typeanal.py b/mypy/newsemanal/typeanal.py
@@ -72,7 +72,7 @@ def analyze_type_alias(node: Expression,
     try:
         type = expr_to_unanalyzed_type(node)
     except TypeTranslationError:
-        api.fail('Invalid type alias: cannot interpret right hand side as a type', node)
+        api.fail('Invalid type alias: expression is not a valid type', node)
         return None
     analyzer = TypeAnalyser(api, tvar_scope, plugin, options, is_typeshed_stub,
                             allow_unnormalized=allow_unnormalized, defining_alias=True,
@@ -402,17 +402,28 @@ def analyze_unbound_type_without_type_info(self, t: UnboundType, sym: SymbolTabl
         # to make sure there are no remaining semanal-only types, then give up.
         t = t.copy_modified(args=self.anal_array(t.args))
         # TODO: Move this message building logic to messages.py.
+        notes = []  # type: List[str]
         if isinstance(sym.node, Var):
-            reason = 'Cannot use variable as type'  # TODO: add link to alias docs, see #3494
+            # TODO: add a link to alias docs, see #3494.
+            message = 'Variable "{}" is not valid as a type'
         elif isinstance(sym.node, (SYMBOL_FUNCBASE_TYPES, Decorator)):
-            reason = 'Cannot use function as type, use Callable[...] or a protocol instead'
+            message = 'Function "{}" is not valid as a type'
+            notes.append('Perhaps you need "Callable[...]" or a callback protocol?')
         elif isinstance(sym.node, MypyFile):
-            reason = 'Module cannot be used as type'  # TODO: suggest a protocol when supported
+            # TODO: suggest a protocol when supported.
+            message = 'Module "{}" is not valid as a type'.format(name)
         elif unbound_tvar:
-            reason = 'Can only use bound type variables as types'
+            message = 'Type variable "{}" is unbound'
+            short = name.split('.')[-1]
+            notes.append(('(Hint: Use "Generic[{}]" or "Protocol[{}]" base class'
+                          ' to bind "{}" inside a class)').format(short, short, short))
+            notes.append('(Hint: Use "{}" in function signature to bind "{}"'
+                         ' inside a function)'.format(short, short))
         else:
-            reason = 'Cannot interpret reference as a type'
-        self.fail('Invalid type "{}": {}'.format(name, reason), t)
+            message = 'Cannot interpret reference "{}" as a type'.format(name)
+        self.fail(message.format(name), t)
+        for note in notes:
+            self.note(note, t)
 
         # TODO: Would it be better to always return Any instead of UnboundType
         # in case of an error? On one hand, UnboundType has a name so error messages
@@ -433,7 +444,8 @@ def visit_deleted_type(self, t: DeletedType) -> Type:
         return t
 
     def visit_type_list(self, t: TypeList) -> Type:
-        self.fail('Invalid type: Did you want to use "List[...]"?', t)
+        self.fail('Bracketed expression "[...]" is not valid as a type', t)
+        self.note('Did you mean "List[...]"?', t)
         return AnyType(TypeOfAny.from_error)
 
     def visit_callable_argument(self, t: CallableArgument) -> Type:
@@ -468,9 +480,9 @@ def visit_tuple_type(self, t: TupleType) -> Type:
         if t.implicit and not self.allow_tuple_literal:
             self.fail('Syntax error in type annotation', t)
             if len(t.items) == 1:
-                self.note_func('Suggestion: Is there a spurious trailing comma?', t)
+                self.note('Suggestion: Is there a spurious trailing comma?', t)
             else:
-                self.note_func('Suggestion: Use Tuple[T1, ..., Tn] instead of (T1, ..., Tn)', t)
+                self.note('Suggestion: Use Tuple[T1, ..., Tn] instead of (T1, ..., Tn)', t)
             return AnyType(TypeOfAny.from_error)
         star_count = sum(1 for item in t.items if isinstance(item, StarType))
         if star_count > 1:
@@ -523,7 +535,7 @@ def visit_raw_expression_type(self, t: RawExpressionType) -> Type:
 
             self.fail(msg, t)
             if t.note is not None:
-                self.note_func(t.note, t)
+                self.note(t.note, t)
 
         return AnyType(TypeOfAny.from_error, line=t.line, column=t.column)
 
@@ -733,6 +745,9 @@ def analyze_type(self, t: Type) -> Type:
     def fail(self, msg: str, ctx: Context) -> None:
         self.fail_func(msg, ctx)
 
+    def note(self, msg: str, ctx: Context) -> None:
+        self.note_func(msg, ctx)
+
     @contextmanager
     def tvar_scope_frame(self) -> Iterator[None]:
         old_scope = self.tvar_scope

diff --git a/mypy/semanal.py b/mypy/semanal.py
@@ -2864,10 +2864,10 @@ def visit_with_stmt(self, s: WithStmt) -> None:
                     types = s.unanalyzed_type.items
                 else:
                     # But it's the wrong number of items
-                    self.fail('Incompatible number of types for `with` targets', s)
+                    self.fail('Incompatible number of types for "with" targets', s)
             else:
                 # We have multiple targets and one type
-                self.fail('Multiple types expected for multiple `with` targets', s)
+                self.fail('Multiple types expected for multiple "with" targets', s)
 
         new_types = []  # type: List[Type]
         for e, n in zip(s.expr, s.target):

diff --git a/test-data/unit/check-basic.test b/test-data/unit/check-basic.test
@@ -332,7 +332,7 @@ from typing import Union
 class A: ...
 class B: ...
 
-x: Union[mock, A]  # E: Invalid type "mock": Module cannot be used as type
+x: Union[mock, A]  # E: Module "mock" is not valid as a type
 
 if isinstance(x, B):
     pass
@@ -348,7 +348,7 @@ from typing import overload, Any, Union
 @overload
 def f(x: int) -> int: ...
 @overload
-def f(x: str) -> Union[mock, str]: ...  # E: Invalid type "mock": Module cannot be used as type
+def f(x: str) -> Union[mock, str]: ...  # E: Module "mock" is not valid as a type
 def f(x):
     pass
 

diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
@@ -4838,8 +4838,8 @@ import six
 class M(type): pass
 class A(object): pass
 def f() -> type: return M
-class C1(six.with_metaclass(M), object): pass  # E: Invalid base class "six.with_metaclass": Unsupported dynamic base class
-class C2(C1, six.with_metaclass(M)): pass  # E: Invalid base class "six.with_metaclass": Unsupported dynamic base class
+class C1(six.with_metaclass(M), object): pass  # E: Unsupported dynamic base class "six.with_metaclass"
+class C2(C1, six.with_metaclass(M)): pass  # E: Unsupported dynamic base class "six.with_metaclass"
 class C3(six.with_metaclass(A)): pass  # E: Metaclasses not inheriting from 'type' are not supported
 @six.add_metaclass(A)  # E: Argument 1 to "add_metaclass" has incompatible type "Type[A]"; expected "Type[type]" \
                        # E: Metaclasses not inheriting from 'type' are not supported

diff --git a/test-data/unit/check-columns.test b/test-data/unit/check-columns.test
@@ -74,16 +74,16 @@ from typing import Iterable
 
 bad = 0
 
-def f(x: bad): # E:10: Invalid type "__main__.bad": Cannot use variable as type
-    y: bad # E:8: Invalid type "__main__.bad": Cannot use variable as type
+def f(x: bad): # E:10: Variable "__main__.bad" is not valid as a type
+    y: bad # E:8: Variable "__main__.bad" is not valid as a type
 
 if int():
-        def g(x): # E:5: Invalid type "__main__.bad": Cannot use variable as type
+    def g(x): # E:5: Variable "__main__.bad" is not valid as a type
         # type: (bad) -> None
-        y = 0  # type: bad  # E:9: Invalid type "__main__.bad": Cannot use variable as type
+        y = 0  # type: bad  # E:9: Variable "__main__.bad" is not valid as a type
 
-z: Iterable[bad] # E:13: Invalid type "__main__.bad": Cannot use variable as type
-h: bad[int] # E:4: Invalid type "__main__.bad": Cannot use variable as type
+z: Iterable[bad] # E:13: Variable "__main__.bad" is not valid as a type
+h: bad[int] # E:4: Variable "__main__.bad" is not valid as a type
 
 [case testColumnInvalidType_python2]
 # flags: --new-semantic-analyzer
@@ -92,11 +92,11 @@ from typing import Iterable
 bad = 0
 
 if int():
-    def g(x): # E:5: Invalid type "__main__.bad": Cannot use variable as type
+    def g(x): # E:5: Variable "__main__.bad" is not valid as a type
         # type: (bad) -> None
-        y = 0  # type: bad  # E:9: Invalid type "__main__.bad": Cannot use variable as type
+        y = 0  # type: bad  # E:9: Variable "__main__.bad" is not valid as a type
 
-    z = ()  # type: Iterable[bad] # E:5: Invalid type "__main__.bad": Cannot use variable as type
+    z = ()  # type: Iterable[bad] # E:5: Variable "__main__.bad" is not valid as a type
 
 [case testColumnFunctionMissingTypeAnnotation]
 # flags: --disallow-untyped-defs

diff --git a/test-data/unit/check-functions.test b/test-data/unit/check-functions.test
@@ -1738,12 +1738,12 @@ J = Callable[[VarArg(), KwArg()], int] # ok
 K = Callable[[VarArg(), int], int] # E: Required positional args may not appear after default, named or var args
 L = Callable[[Arg(name='x', type=int)], int] # ok
 # I have commented out the following test because I don't know how to expect the "defined here" note part of the error.
-# M = Callable[[Arg(gnome='x', type=int)], int]   E: Invalid type alias: cannot interpret right hand side as a type   E: Unexpected keyword argument "gnome" for "Arg"
+# M = Callable[[Arg(gnome='x', type=int)], int]   E: Invalid type alias: expression is not a valid type   E: Unexpected keyword argument "gnome" for "Arg"
 N = Callable[[Arg(name=None, type=int)], int] # ok
-O = Callable[[List[Arg(int)]], int]  # E: Invalid type alias: cannot interpret right hand side as a type  # E: Value of type "int" is not indexable  # E: Type expected within [...] # E: The type "Type[List[Any]]" is not generic and not indexable
+O = Callable[[List[Arg(int)]], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: Type expected within [...] # E: The type "Type[List[Any]]" is not generic and not indexable
 P = Callable[[mypy_extensions.VarArg(int)], int] # ok
-Q = Callable[[Arg(int, type=int)], int]  # E: Invalid type alias: cannot interpret right hand side as a type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "type"
-R = Callable[[Arg(int, 'x', name='y')], int]  # E: Invalid type alias: cannot interpret right hand side as a type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "name"
+Q = Callable[[Arg(int, type=int)], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "type"
+R = Callable[[Arg(int, 'x', name='y')], int]  # E: Invalid type alias: expression is not a valid type  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "name"
 
 [builtins fixtures/dict.pyi]
 

diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
@@ -978,9 +978,9 @@ class C:
         b = int  # E: Cannot assign multiple types to name "b" without an explicit "Type[...]" annotation
     if int():
         c = int
-    def f(self, x: a) -> None: pass  # E: Invalid type "__main__.C.a": Cannot use variable as type
+    def f(self, x: a) -> None: pass  # E: Variable "__main__.C.a" is not valid as a type
     def g(self, x: b) -> None: pass
-    def h(self, x: c) -> None: pass  # E: Invalid type "__main__.C.c": Cannot use variable as type
+    def h(self, x: c) -> None: pass  # E: Variable "__main__.C.a" is not valid as a type
     x: b
     reveal_type(x)  # N: Revealed type is 'Union[builtins.int, builtins.str]'
 [out]

diff --git a/test-data/unit/check-incremental.test b/test-data/unit/check-incremental.test
@@ -2196,9 +2196,11 @@ from b import x
 1 + 1
 [out]
 [out2]
-tmp/b.py:2: error: Invalid type "c.C": Cannot use function as type, use Callable[...] or a protocol instead
+tmp/b.py:2: error: Function "c.C" is not valid as a type
+tmp/b.py:2: note: Perhaps you need "Callable[...]" or a callback protocol?
 [out3]
-tmp/b.py:2: error: Invalid type "c.C": Cannot use function as type, use Callable[...] or a protocol instead
+tmp/b.py:2: error: Function "c.C" is not valid as a type
+tmp/b.py:2: note: Perhaps you need "Callable[...]" or a callback protocol?
 
 [case testCacheDeletedAfterErrorsFound3]
 import a

diff --git a/test-data/unit/check-modules.test b/test-data/unit/check-modules.test
@@ -824,7 +824,8 @@ MYPY = False
 if MYPY:
     from a import Session
 
-def f(self, session: Session) -> None:  # E: Invalid type "a.Session": Cannot use function as type, use Callable[...] or a protocol instead
+def f(self, session: Session) -> None:  # E: Function "a.Session" is not valid as a type \
+                                        # N: Perhaps you need "Callable[...]" or a callback protocol?
     pass
 [builtins fixtures/bool.pyi]
 

diff --git a/test-data/unit/check-statements.test b/test-data/unit/check-statements.test
@@ -1357,7 +1357,7 @@ class A:
     def __enter__(self) -> int: pass
     def __exit__(self, x, y, z): pass
 
-with A():  # type: int  # E: Invalid type comment: `with` statement has no targets
+with A():  # type: int  # E: Invalid type comment: "with" statement has no targets
     pass
 
 with A() as a:  # type: int
@@ -1424,7 +1424,7 @@ with A() as e, A() as (f, g), B() as h:  # type: Tuple[int, int], Tuple[int, int
 with A() as i, A() as (j, k), B() as l:  # type: (int, int), (int, int), str  # E: Syntax error in type annotation # N: Suggestion: Use Tuple[T1, ..., Tn] instead of (T1, ..., Tn)
     pass
 
-with A(), A(), B() as m, A() as n, B(), B() as o:  # type: int, Tuple[int, int]  # E: Incompatible number of types for `with` targets
+with A(), A(), B() as m, A() as n, B(), B() as o:  # type: int, Tuple[int, int]  # E: Incompatible number of types for "with" targets
     pass
 
 with A(), B(), B() as p, A(), A():  # type: str