Repository: python/mypy

Issue:
MessageBuilder.format inconsistently surrounds types with quotes
When working on #3402, using `msg.format` for types usually surrounded them with quotes, e.g., in test `testUnionAttributeAccess`, calling `msg.format` while printing generates the following:
```
Element "C" of "Union[A, C]" has no attribute "y"
```
However, in one test case, ``, the type is not surrounded by quotes (see last line, I attached the entire test case for context):

```
 [case testGenericTypeAliasesUnion]
 from typing import TypeVar, Generic, Union, Any
 T = TypeVar('T')
 class Node(Generic[T]):
     def __init__(self, x: T) -> None:
         self.x = x
 
 UNode = Union[int, Node[T]]
 x = 1 # type: UNode[int]
 
 x + 1 # E: Unsupported left operand type for + (some union)
 if not isinstance(x, Node):
     x + 1
 
 if not isinstance(x, int):
    x.x = 1
    x.x = 'a' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 def f(x: T) -> UNode[T]:
     if 1:
         return Node(x)
     else:
         return 1
 
 reveal_type(f(1)) # E: Revealed type is 'Union[builtins.int, __main__.Node[builtins.int*]]'
 
 TNode = Union[T, Node[int]]
 s = 1 # type: TNode[str] # E: Incompatible types in assignment (expression has type "int", variable has type "Union[str, Node[int]]")
 
 if not isinstance(s, str):
     s.x = 1
  
  z = None # type: TNode # Same as TNode[Any]
  z.x
  z.foo() # E: Element Node[int] of "Union[Any, Node[int]]" has no attribute "foo"
```
Notice how `Node[int]` is not surrounded by quotes. The relevant `format` function is defined in `mypy/messages.py`.

(Sorry for only reproducing this in an unrelated test, I don't have enough knowledge on the code base to  create the relevant type object directly).


Discussion:
I think this is on purpose. See this comment in ``format_simple``:
```python
                # No type arguments. Place the type name in quotes to avoid
                # potential for confusion: otherwise, the type name could be
                # interpreted as a normal word.
```
The idea is that type with arguments (i.e. with ``[...]``) is already visible enough. If you think it is not, then you could just remove this check https://github.com/python/mypy/blob/master/mypy/messages.py#L255
The reasoning in that comment could be a good idea, but I think it'd be hard to do consistently -- and certainly we don't do it consistently today. For example this error message in the quoted test:

> Element Node[int] of "Union[Any, Node[int]]" has no attribute "foo"

I took a quick look at how C compilers format types in error messages. Both Clang and GCC seem to consistently quote all types, with single quotes, both simple and complicated: https://gcc.gnu.org/wiki/ClangDiagnosticsComparison

So I think we should be consistent too. We're also inconsistent on single vs. double quotes (see again the quoted test), which would also be good to fix but I think is a lower level of issue.

Resolving patch:
diff --git a/mypy/messages.py b/mypy/messages.py
--- a/mypy/messages.py
+++ b/mypy/messages.py
@@ -184,69 +184,30 @@ def warn(self, msg: str, context: Context, file: Optional[str] = None,
         self.report(msg, context, 'warning', file=file, origin=origin)
 
     def format(self, typ: Type, verbosity: int = 0) -> str:
-        """Convert a type to a relatively short string that is suitable for error messages.
-
-        Mostly behave like format_simple below, but never return an empty string.
         """
-        s = self.format_simple(typ, verbosity)
-        if s != '':
-            # If format_simple returns a non-trivial result, use that.
-            return s
-        elif isinstance(typ, FunctionLike):
-            func = typ
-            if func.is_type_obj():
-                # The type of a type object type can be derived from the
-                # return type (this always works).
-                return self.format(TypeType.make_normalized(erase_type(func.items()[0].ret_type)),
-                                   verbosity)
-            elif isinstance(func, CallableType):
-                return_type = strip_quotes(self.format(func.ret_type))
-                if func.is_ellipsis_args:
-                    return 'Callable[..., {}]'.format(return_type)
-                arg_strings = []
-                for arg_name, arg_type, arg_kind in zip(
-                        func.arg_names, func.arg_types, func.arg_kinds):
-                    if (arg_kind == ARG_POS and arg_name is None
-                            or verbosity == 0 and arg_kind in (ARG_POS, ARG_OPT)):
-
-                        arg_strings.append(
-                            strip_quotes(
-                                self.format(
-                                    arg_type,
-                                    verbosity = max(verbosity - 1, 0))))
-                    else:
-                        constructor = ARG_CONSTRUCTOR_NAMES[arg_kind]
-                        if arg_kind in (ARG_STAR, ARG_STAR2) or arg_name is None:
-                            arg_strings.append("{}({})".format(
-                                constructor,
-                                strip_quotes(self.format(arg_type))))
-                        else:
-                            arg_strings.append("{}({}, {})".format(
-                                constructor,
-                                strip_quotes(self.format(arg_type)),
-                                repr(arg_name)))
-
-                return 'Callable[[{}], {}]'.format(", ".join(arg_strings), return_type)
-            else:
-                # Use a simple representation for function types; proper
-                # function types may result in long and difficult-to-read
-                # error messages.
-                return 'overloaded function'
-        else:
-            # Default case; we simply have to return something meaningful here.
-            return 'object'
-
-    def format_simple(self, typ: Type, verbosity: int = 0) -> str:
-        """Convert simple types to string that is suitable for error messages.
+        Convert a type to a relatively short string suitable for error messages.
 
-        Return "" for complex types. Try to keep the length of the result
-        relatively short to avoid overly long error messages.
+        This method returns a string appropriate for unmodified use in error
+        messages; this means that it will be quoted in most cases.  If
+        modification of the formatted string is required, callers should use
+        .format_bare.
+        """
+        ret = self.format_bare(typ, verbosity)
+        no_quote_regex = r'^tuple\(length \d+\)$'
+        if (ret in ['Module', 'overloaded function', '<nothing>', '<deleted>']
+                or re.match(no_quote_regex, ret) is not None):
+            # Messages are easier to read if these aren't quoted.  We use a
+            # regex to match strings with variable contents.
+            return ret
+        return '"{}"'.format(ret)
+
+    def format_bare(self, typ: Type, verbosity: int = 0) -> str:
+        """
+        Convert a type to a relatively short string suitable for error messages.
 
-        Examples:
-          builtins.int -> 'int'
-          Any type -> 'Any'
-          None -> None
-          callable type -> "" (empty string)
+        This method will return an unquoted string.  If a caller doesn't need to
+        perform post-processing on the string output, .format should be used
+        instead.
         """
         if isinstance(typ, Instance):
             itype = typ
@@ -260,26 +221,22 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
             else:
                 base_str = itype.type.name()
             if itype.args == []:
-                # No type arguments. Place the type name in quotes to avoid
-                # potential for confusion: otherwise, the type name could be
-                # interpreted as a normal word.
-                return '"{}"'.format(base_str)
+                # No type arguments, just return the type name
+                return base_str
             elif itype.type.fullname() == 'builtins.tuple':
-                item_type_str = strip_quotes(self.format(itype.args[0]))
+                item_type_str = self.format_bare(itype.args[0])
                 return 'Tuple[{}, ...]'.format(item_type_str)
             elif itype.type.fullname() in reverse_type_aliases:
                 alias = reverse_type_aliases[itype.type.fullname()]
                 alias = alias.split('.')[-1]
-                items = [strip_quotes(self.format(arg)) for arg in itype.args]
+                items = [self.format_bare(arg) for arg in itype.args]
                 return '{}[{}]'.format(alias, ', '.join(items))
             else:
-                # There are type arguments. Convert the arguments to strings
-                # (using format() instead of format_simple() to avoid empty
-                # strings). If the result is too long, replace arguments
-                # with [...].
+                # There are type arguments. Convert the arguments to strings.
+                # If the result is too long, replace arguments with [...].
                 a = []  # type: List[str]
                 for arg in itype.args:
-                    a.append(strip_quotes(self.format(arg)))
+                    a.append(self.format_bare(arg))
                 s = ', '.join(a)
                 if len((base_str + s)) < 150:
                     return '{}[{}]'.format(base_str, s)
@@ -287,15 +244,15 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
                     return '{}[...]'.format(base_str)
         elif isinstance(typ, TypeVarType):
             # This is similar to non-generic instance types.
-            return '"{}"'.format(typ.name)
+            return typ.name
         elif isinstance(typ, TupleType):
             # Prefer the name of the fallback class (if not tuple), as it's more informative.
             if typ.fallback.type.fullname() != 'builtins.tuple':
-                return self.format_simple(typ.fallback)
+                return self.format_bare(typ.fallback)
             items = []
             for t in typ.items:
-                items.append(strip_quotes(self.format(t)))
-            s = '"Tuple[{}]"'.format(', '.join(items))
+                items.append(self.format_bare(t))
+            s = 'Tuple[{}]'.format(', '.join(items))
             if len(s) < 400:
                 return s
             else:
@@ -303,14 +260,14 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
         elif isinstance(typ, TypedDictType):
             # If the TypedDictType is named, return the name
             if not typ.is_anonymous():
-                return self.format_simple(typ.fallback)
+                return self.format_bare(typ.fallback)
             items = []
             for (item_name, item_type) in typ.items.items():
                 modifier = '' if item_name in typ.required_keys else '?'
                 items.append('{!r}{}: {}'.format(item_name,
                                                  modifier,
-                                                 strip_quotes(self.format(item_type))))
-            s = '"TypedDict({{{}}})"'.format(', '.join(items))
+                                                 self.format_bare(item_type)))
+            s = 'TypedDict({{{}}})'.format(', '.join(items))
             return s
         elif isinstance(typ, UnionType):
             # Only print Unions as Optionals if the Optional wouldn't have to contain another Union
@@ -318,12 +275,12 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
                                  sum(isinstance(t, NoneTyp) for t in typ.items) == 1)
             if print_as_optional:
                 rest = [t for t in typ.items if not isinstance(t, NoneTyp)]
-                return '"Optional[{}]"'.format(strip_quotes(self.format(rest[0])))
+                return 'Optional[{}]'.format(self.format_bare(rest[0]))
             else:
                 items = []
                 for t in typ.items:
-                    items.append(strip_quotes(self.format(t)))
-                s = '"Union[{}]"'.format(', '.join(items))
+                    items.append(self.format_bare(t))
+                s = 'Union[{}]'.format(', '.join(items))
                 if len(s) < 400:
                     return s
                 else:
@@ -331,7 +288,7 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
         elif isinstance(typ, NoneTyp):
             return 'None'
         elif isinstance(typ, AnyType):
-            return '"Any"'
+            return 'Any'
         elif isinstance(typ, DeletedType):
             return '<deleted>'
         elif isinstance(typ, UninhabitedType):
@@ -340,25 +297,72 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
             else:
                 return '<nothing>'
         elif isinstance(typ, TypeType):
-            return 'Type[{}]'.format(
-                strip_quotes(self.format_simple(typ.item, verbosity)))
+            return 'Type[{}]'.format(self.format_bare(typ.item, verbosity))
+        elif isinstance(typ, FunctionLike):
+            func = typ
+            if func.is_type_obj():
+                # The type of a type object type can be derived from the
+                # return type (this always works).
+                return self.format_bare(
+                    TypeType.make_normalized(
+                        erase_type(func.items()[0].ret_type)),
+                    verbosity)
+            elif isinstance(func, CallableType):
+                return_type = self.format_bare(func.ret_type)
+                if func.is_ellipsis_args:
+                    return 'Callable[..., {}]'.format(return_type)
+                arg_strings = []
+                for arg_name, arg_type, arg_kind in zip(
+                        func.arg_names, func.arg_types, func.arg_kinds):
+                    if (arg_kind == ARG_POS and arg_name is None
+                            or verbosity == 0 and arg_kind in (ARG_POS, ARG_OPT)):
+
+                        arg_strings.append(
+                            self.format_bare(
+                                arg_type,
+                                verbosity = max(verbosity - 1, 0)))
+                    else:
+                        constructor = ARG_CONSTRUCTOR_NAMES[arg_kind]
+                        if arg_kind in (ARG_STAR, ARG_STAR2) or arg_name is None:
+                            arg_strings.append("{}({})".format(
+                                constructor,
+                                self.format_bare(arg_type)))
+                        else:
+                            arg_strings.append("{}({}, {})".format(
+                                constructor,
+                                self.format_bare(arg_type),
+                                repr(arg_name)))
+
+                return 'Callable[[{}], {}]'.format(", ".join(arg_strings), return_type)
+            else:
+                # Use a simple representation for function types; proper
+                # function types may result in long and difficult-to-read
+                # error messages.
+                return 'overloaded function'
         elif typ is None:
             raise RuntimeError('Type is None')
         else:
-            # No simple representation for this type that would convey very
-            # useful information. No need to mention the type explicitly in a
-            # message.
-            return ''
+            # Default case; we simply have to return something meaningful here.
+            return 'object'
 
-    def format_distinctly(self, type1: Type, type2: Type) -> Tuple[str, str]:
+    def format_distinctly(self, type1: Type, type2: Type, bare: bool = False) -> Tuple[str, str]:
         """Jointly format a pair of types to distinct strings.
 
         Increase the verbosity of the type strings until they become distinct.
+
+        By default, the returned strings are created using .format() and will be
+        quoted accordingly. If ``bare`` is True, the returned strings will not
+        be quoted; callers who need to do post-processing of the strings before
+        quoting them (such as prepending * or **) should use this.
         """
+        if bare:
+            format_method = self.format_bare
+        else:
+            format_method = self.format
         verbosity = 0
         for verbosity in range(3):
-            str1 = self.format(type1, verbosity=verbosity)
-            str2 = self.format(type2, verbosity=verbosity)
+            str1 = format_method(type1, verbosity=verbosity)
+            str2 = format_method(type2, verbosity=verbosity)
             if str1 != str2:
                 return (str1, str2)
         return (str1, str2)
@@ -604,12 +608,13 @@ def incompatible_argument(self, n: int, m: int, callee: CallableType, arg_type:
                 expected_type = callee.arg_types[m - 1]
             except IndexError:  # Varargs callees
                 expected_type = callee.arg_types[-1]
-            arg_type_str, expected_type_str = self.format_distinctly(arg_type, expected_type)
+            arg_type_str, expected_type_str = self.format_distinctly(
+                arg_type, expected_type, bare=True)
             if arg_kind == ARG_STAR:
                 arg_type_str = '*' + arg_type_str
             elif arg_kind == ARG_STAR2:
                 arg_type_str = '**' + arg_type_str
-            msg = 'Argument {} {}has incompatible type {}; expected {}'.format(
+            msg = 'Argument {} {}has incompatible type "{}"; expected "{}"'.format(
                 n, target, arg_type_str, expected_type_str)
             if isinstance(arg_type, Instance) and isinstance(expected_type, Instance):
                 notes = append_invariance_notes(notes, arg_type, expected_type)
@@ -1014,16 +1019,16 @@ def bad_proto_variance(self, actual: int, tvar_name: str, expected: int,
         self.fail(msg, context)
 
     def concrete_only_assign(self, typ: Type, context: Context) -> None:
-        self.fail("Can only assign concrete classes to a variable of type '{}'"
+        self.fail("Can only assign concrete classes to a variable of type {}"
                   .format(self.format(typ)), context)
 
     def concrete_only_call(self, typ: Type, context: Context) -> None:
-        self.fail("Only concrete class can be given where '{}' is expected"
+        self.fail("Only concrete class can be given where {} is expected"
                   .format(self.format(typ)), context)
 
     def note_call(self, subtype: Type, call: Type, context: Context) -> None:
-        self.note("'{}.__call__' has type '{}'".format(strip_quotes(self.format(subtype)),
-                                                       self.format(call, verbosity=1)), context)
+        self.note("'{}.__call__' has type {}".format(self.format_bare(subtype),
+                                                     self.format(call, verbosity=1)), context)
 
     def report_protocol_problems(self, subtype: Union[Instance, TupleType, TypedDictType],
                                  supertype: Instance, context: Context) -> None:
@@ -1148,7 +1153,7 @@ def [T <: int] f(self, x: int, y: T) -> None
             name = tp.arg_names[i]
             if name:
                 s += name + ': '
-            s += strip_quotes(self.format(tp.arg_types[i]))
+            s += self.format_bare(tp.arg_types[i])
             if tp.arg_kinds[i] in (ARG_OPT, ARG_NAMED_OPT):
                 s += ' = ...'
 
@@ -1164,17 +1169,17 @@ def [T <: int] f(self, x: int, y: T) -> None
         else:
             s = '({})'.format(s)
 
-        s += ' -> ' + strip_quotes(self.format(tp.ret_type))
+        s += ' -> ' + self.format_bare(tp.ret_type)
         if tp.variables:
             tvars = []
             for tvar in tp.variables:
                 if (tvar.upper_bound and isinstance(tvar.upper_bound, Instance) and
                         tvar.upper_bound.type.fullname() != 'builtins.object'):
                     tvars.append('{} <: {}'.format(tvar.name,
-                                                   strip_quotes(self.format(tvar.upper_bound))))
+                                                   self.format_bare(tvar.upper_bound)))
                 elif tvar.values:
                     tvars.append('{} in ({})'
-                                 .format(tvar.name, ', '.join([strip_quotes(self.format(tp))
+                                 .format(tvar.name, ', '.join([self.format_bare(tp)
                                                                for tp in tvar.values])))
                 else:
                     tvars.append(tvar.name)


Test patch:
diff --git a/test-data/unit/check-abstract.test b/test-data/unit/check-abstract.test
--- a/test-data/unit/check-abstract.test
+++ b/test-data/unit/check-abstract.test
@@ -174,8 +174,8 @@ def f(cls: Type[A]) -> A:
 def g() -> A:
     return A()  # E: Cannot instantiate abstract class 'A' with abstract attribute 'm'
 
-f(A)  # E: Only concrete class can be given where 'Type[A]' is expected
-f(B)  # E: Only concrete class can be given where 'Type[A]' is expected
+f(A)  # E: Only concrete class can be given where "Type[A]" is expected
+f(B)  # E: Only concrete class can be given where "Type[A]" is expected
 f(C)  # OK
 x: Type[B]
 f(x)  # OK
@@ -200,7 +200,7 @@ Alias = A
 GoodAlias = C
 Alias()  # E: Cannot instantiate abstract class 'A' with abstract attribute 'm'
 GoodAlias()
-f(Alias)  # E: Only concrete class can be given where 'Type[A]' is expected
+f(Alias)  # E: Only concrete class can be given where "Type[A]" is expected
 f(GoodAlias)
 [out]
 
@@ -218,14 +218,14 @@ class C(B):
 
 var: Type[A]
 var()
-var = A # E: Can only assign concrete classes to a variable of type 'Type[A]'
-var = B # E: Can only assign concrete classes to a variable of type 'Type[A]'
+var = A # E: Can only assign concrete classes to a variable of type "Type[A]"
+var = B # E: Can only assign concrete classes to a variable of type "Type[A]"
 var = C # OK
 
 var_old = None # type: Type[A] # Old syntax for variable annotations
 var_old()
-var_old = A # E: Can only assign concrete classes to a variable of type 'Type[A]'
-var_old = B # E: Can only assign concrete classes to a variable of type 'Type[A]'
+var_old = A # E: Can only assign concrete classes to a variable of type "Type[A]"
+var_old = B # E: Can only assign concrete classes to a variable of type "Type[A]"
 var_old = C # OK
 [out]
 
diff --git a/test-data/unit/check-async-await.test b/test-data/unit/check-async-await.test
--- a/test-data/unit/check-async-await.test
+++ b/test-data/unit/check-async-await.test
@@ -93,7 +93,7 @@ async def f() -> int:
     return x
 [typing fixtures/typing-full.pyi]
 [out]
-main:7: error: Incompatible types in await (actual type Generator[int, None, str], expected type Awaitable[Any])
+main:7: error: Incompatible types in await (actual type "Generator[int, None, str]", expected type "Awaitable[Any]")
 
 [case testAwaitIteratorError]
 
@@ -105,7 +105,7 @@ async def f() -> int:
     return x
 [typing fixtures/typing-full.pyi]
 [out]
-main:6: error: Incompatible types in await (actual type Iterator[Any], expected type Awaitable[Any])
+main:6: error: Incompatible types in await (actual type "Iterator[Any]", expected type "Awaitable[Any]")
 
 [case testAwaitArgumentError]
 
@@ -117,7 +117,7 @@ async def f() -> int:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
 [out]
-main:5: error: Incompatible types in await (actual type "int", expected type Awaitable[Any])
+main:5: error: Incompatible types in await (actual type "int", expected type "Awaitable[Any]")
 
 [case testAwaitResultError]
 
@@ -164,7 +164,7 @@ async def f() -> None:
 [typing fixtures/typing-full.pyi]
 [out]
 main:4: error: AsyncIterable expected
-main:4: error: List[int] has no attribute "__aiter__"
+main:4: error: "List[int]" has no attribute "__aiter__"
 
 [case testAsyncForTypeComments]
 
@@ -248,13 +248,13 @@ async def wrong_iterable(obj: Iterable[int]):
 
 [out]
 main:18: error: AsyncIterable expected
-main:18: error: Iterable[int] has no attribute "__aiter__"; maybe "__iter__"?
+main:18: error: "Iterable[int]" has no attribute "__aiter__"; maybe "__iter__"?
 main:19: error: Iterable expected
-main:19: error: asyncify[int] has no attribute "__iter__"; maybe "__aiter__"?
+main:19: error: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"?
 main:20: error: AsyncIterable expected
-main:20: error: Iterable[int] has no attribute "__aiter__"; maybe "__iter__"?
+main:20: error: "Iterable[int]" has no attribute "__aiter__"; maybe "__iter__"?
 main:21: error: Iterable expected
-main:21: error: asyncify[int] has no attribute "__iter__"; maybe "__aiter__"?
+main:21: error: "asyncify[int]" has no attribute "__iter__"; maybe "__aiter__"?
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
 
@@ -290,7 +290,7 @@ class C:
     def __aenter__(self) -> int: pass
     async def __aexit__(self, x, y, z) -> None: pass
 async def f() -> None:
-    async with C() as x:  # E: Incompatible types in "async with" for __aenter__ (actual type "int", expected type Awaitable[Any])
+    async with C() as x:  # E: Incompatible types in "async with" for __aenter__ (actual type "int", expected type "Awaitable[Any]")
         pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
@@ -301,7 +301,7 @@ class C:
     def __aenter__(self) -> None: pass
     async def __aexit__(self, x, y, z) -> None: pass
 async def f() -> None:
-    async with C() as x:  # E: None has no attribute "__await__"
+    async with C() as x:  # E: "None" has no attribute "__await__"
         pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
@@ -312,7 +312,7 @@ class C:
     async def __aenter__(self) -> int: pass
     def __aexit__(self, x, y, z) -> int: pass
 async def f() -> None:
-    async with C() as x: # E: Incompatible types in "async with" for __aexit__ (actual type "int", expected type Awaitable[Any])
+    async with C() as x: # E: Incompatible types in "async with" for __aexit__ (actual type "int", expected type "Awaitable[Any]")
         pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
@@ -323,7 +323,7 @@ class C:
     async def __aenter__(self) -> int: pass
     def __aexit__(self, x, y, z) -> None: pass
 async def f() -> None:
-    async with C() as x: # E: None has no attribute "__await__"
+    async with C() as x: # E: "None" has no attribute "__await__"
         pass
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
@@ -383,7 +383,7 @@ def g() -> Generator[Any, None, str]:
 [builtins fixtures/async_await.pyi]
 [typing fixtures/typing-full.pyi]
 [out]
-main:6: error: "yield from" can't be applied to Awaitable[str]
+main:6: error: "yield from" can't be applied to "Awaitable[str]"
 
 [case testAwaitableSubclass]
 
@@ -550,7 +550,7 @@ def h() -> None:
 
 [out]
 main:9: error: Iterable expected
-main:9: error: AsyncGenerator[int, None] has no attribute "__iter__"; maybe "__aiter__"?
+main:9: error: "AsyncGenerator[int, None]" has no attribute "__iter__"; maybe "__aiter__"?
 
 [case testAsyncGeneratorNoYieldFrom]
 # flags: --fast-parser --python-version 3.6
@@ -636,19 +636,19 @@ def plain_host_generator() -> Generator[str, None, None]:
     yield 'a'
     x = 0
     x = yield from plain_generator()
-    x = yield from plain_coroutine()  # E: "yield from" can't be applied to Awaitable[int]
+    x = yield from plain_coroutine()  # E: "yield from" can't be applied to "Awaitable[int]"
     x = yield from decorated_generator()
-    x = yield from decorated_coroutine()  # E: "yield from" can't be applied to AwaitableGenerator[Any, Any, int, Awaitable[int]]
+    x = yield from decorated_coroutine()  # E: "yield from" can't be applied to "AwaitableGenerator[Any, Any, int, Awaitable[int]]"
     x = yield from other_iterator()
     x = yield from other_coroutine()  # E: "yield from" can't be applied to "Aw"
 
 async def plain_host_coroutine() -> None:
     x = 0
-    x = await plain_generator()  # E: Incompatible types in await (actual type Generator[str, None, int], expected type Awaitable[Any])
+    x = await plain_generator()  # E: Incompatible types in await (actual type "Generator[str, None, int]", expected type "Awaitable[Any]")
     x = await plain_coroutine()
     x = await decorated_generator()
     x = await decorated_coroutine()
-    x = await other_iterator()  # E: Incompatible types in await (actual type "It", expected type Awaitable[Any])
+    x = await other_iterator()  # E: Incompatible types in await (actual type "It", expected type "Awaitable[Any]")
     x = await other_coroutine()
 
 @coroutine
@@ -665,11 +665,11 @@ def decorated_host_generator() -> Generator[str, None, None]:
 @coroutine
 async def decorated_host_coroutine() -> None:
     x = 0
-    x = await plain_generator()  # E: Incompatible types in await (actual type Generator[str, None, int], expected type Awaitable[Any])
+    x = await plain_generator()  # E: Incompatible types in await (actual type "Generator[str, None, int]", expected type "Awaitable[Any]")
     x = await plain_coroutine()
     x = await decorated_generator()
     x = await decorated_coroutine()
-    x = await other_iterator()  # E: Incompatible types in await (actual type "It", expected type Awaitable[Any])
+    x = await other_iterator()  # E: Incompatible types in await (actual type "It", expected type "Awaitable[Any]")
     x = await other_coroutine()
 
 [builtins fixtures/async_await.pyi]
diff --git a/test-data/unit/check-class-namedtuple.test b/test-data/unit/check-class-namedtuple.test
--- a/test-data/unit/check-class-namedtuple.test
+++ b/test-data/unit/check-class-namedtuple.test
@@ -221,7 +221,7 @@ class MyNamedTuple(NamedTuple):
     a: int
     b: str
 
-MyNamedTuple.x # E: Type[MyNamedTuple] has no attribute "x"
+MyNamedTuple.x # E: "Type[MyNamedTuple]" has no attribute "x"
 
 [case testNewNamedTupleEmptyItems]
 # flags: --python-version 3.6
@@ -439,13 +439,13 @@ class HasNone(NamedTuple):
     y: Optional[int] = None
 
 reveal_type(HasNone(1))  # E: Revealed type is 'Tuple[builtins.int, Union[builtins.int, builtins.None], fallback=__main__.HasNone]'
-HasNone(None)  # E: Argument 1 to "HasNone" has incompatible type None; expected "int"
+HasNone(None)  # E: Argument 1 to "HasNone" has incompatible type "None"; expected "int"
 HasNone(1, y=None)
 HasNone(1, y=2)
 
 class CannotBeNone(NamedTuple):
     x: int
-    y: int = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+    y: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 
 [builtins fixtures/list.pyi]
 
diff --git a/test-data/unit/check-classes.test b/test-data/unit/check-classes.test
--- a/test-data/unit/check-classes.test
+++ b/test-data/unit/check-classes.test
@@ -504,8 +504,8 @@ class A:
     h = f # type: Callable[[A], None]
     h = f
     g = h
-    ff = f # type: Callable[[B], None]  # E: Incompatible types in assignment (expression has type Callable[[A], None], variable has type Callable[[B], None])
-    g = ff                # E: Incompatible types in assignment (expression has type Callable[[B], None], variable has type Callable[[A], None])
+    ff = f # type: Callable[[B], None]  # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[B], None]")
+    g = ff                # E: Incompatible types in assignment (expression has type "Callable[[B], None]", variable has type "Callable[[A], None]")
 [out]
 
 
@@ -551,7 +551,7 @@ b = A.x # type: B # E: Incompatible types in assignment (expression has type "A"
 [case testAccessingUndefinedAttributeViaClass]
 import typing
 class A: pass
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testAccessingUndefinedAttributeViaClassWithOverloadedInit]
 from foo import *
@@ -562,7 +562,7 @@ class A:
     def __init__(self): pass
     @overload
     def __init__(self, x): pass
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testAccessMethodOfClassWithOverloadedInit]
 from foo import *
@@ -864,7 +864,7 @@ class C:
     cls(1)      # E: Too many arguments for "C"
     cls.bar()
     cls.bar(1)  # E: Too many arguments for "bar" of "C"
-    cls.bozo()  # E: Type[C] has no attribute "bozo"
+    cls.bozo()  # E: "Type[C]" has no attribute "bozo"
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -875,7 +875,7 @@ class C:
   def foo(cls) -> None: pass
 C.foo()
 C.foo(1)  # E: Too many arguments for "foo" of "C"
-C.bozo()  # E: Type[C] has no attribute "bozo"
+C.bozo()  # E: "Type[C]" has no attribute "bozo"
 [builtins fixtures/classmethod.pyi]
 
 [case testClassMethodCalledOnInstance]
@@ -885,7 +885,7 @@ class C:
   def foo(cls) -> None: pass
 C().foo()
 C().foo(1)  # E: Too many arguments for "foo" of "C"
-C.bozo()    # E: Type[C] has no attribute "bozo"
+C.bozo()    # E: "Type[C]" has no attribute "bozo"
 [builtins fixtures/classmethod.pyi]
 
 [case testClassMethodMayCallAbstractMethod]
@@ -1330,7 +1330,7 @@ class D:
     def __get__(self, inst: Any, own: str) -> Any: pass
 class A:
     f = D()
-A().f  # E: Argument 2 to "__get__" of "D" has incompatible type Type[A]; expected "str"
+A().f  # E: Argument 2 to "__get__" of "D" has incompatible type "Type[A]"; expected "str"
 
 [case testDescriptorGetSetDifferentTypes]
 from typing import Any
@@ -1853,7 +1853,7 @@ class C:
 def f(x: type) -> None: pass
 def g(x: int) -> None: pass
 f(C)
-g(C) # E: Argument 1 to "g" has incompatible type Type[C]; expected "int"
+g(C) # E: Argument 1 to "g" has incompatible type "Type[C]"; expected "int"
 [builtins fixtures/__new__.pyi]
 
 [case testClassWith__new__AndCompatibilityWithType2]
@@ -1864,7 +1864,7 @@ class C:
 def f(x: type) -> None: pass
 def g(x: int) -> None: pass
 f(C)
-g(C) # E: Argument 1 to "g" has incompatible type Type[C]; expected "int"
+g(C) # E: Argument 1 to "g" has incompatible type "Type[C]"; expected "int"
 [builtins fixtures/__new__.pyi]
 
 [case testGenericClassWith__new__]
@@ -1944,7 +1944,7 @@ class B:
 [case testClassVsInstanceDisambiguation]
 class A: pass
 def f(x: A) -> None: pass
-f(A) # E: Argument 1 to "f" has incompatible type Type[A]; expected "A"
+f(A) # E: Argument 1 to "f" has incompatible type "Type[A]"; expected "A"
 [out]
 
 -- TODO
@@ -2151,7 +2151,7 @@ class User: pass
 def new_user(user_class: Type[User]):
     return user_class()
 def foo(arg: Type[int]):
-    new_user(arg)  # E: Argument 1 to "new_user" has incompatible type Type[int]; expected Type[User]
+    new_user(arg)  # E: Argument 1 to "new_user" has incompatible type "Type[int]"; expected "Type[User]"
 [out]
 
 [case testTypeUsingTypeCUnionOverload]
@@ -2190,7 +2190,7 @@ def foo(arg: Type[Any]):
     # Member access is ok and types as Any
     reveal_type(x)  # E: Revealed type is 'Any'
     # But Type[Any] is distinct from Any
-    y: int = arg  # E: Incompatible types in assignment (expression has type Type[Any], variable has type "int")
+    y: int = arg  # E: Incompatible types in assignment (expression has type "Type[Any]", variable has type "int")
 [out]
 
 [case testTypeUsingTypeCTypeAnyMemberFallback]
@@ -2231,7 +2231,7 @@ def process(cls: Type[User]):
     obj = cls()
     reveal_type(cls.bar(obj))  # E: Revealed type is 'builtins.int'
     cls.mro()  # Defined in class type
-    cls.error  # E: Type[User] has no attribute "error"
+    cls.error  # E: "Type[User]" has no attribute "error"
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -2264,7 +2264,7 @@ def process(cls: Type[U]):
     obj = cls()
     reveal_type(cls.bar(obj))  # E: Revealed type is 'builtins.int'
     cls.mro()  # Defined in class type
-    cls.error  # E: Type[U] has no attribute "error"
+    cls.error  # E: "Type[U]" has no attribute "error"
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -2279,11 +2279,11 @@ class ProUser(User): pass
 class BasicUser(User): pass
 U = TypeVar('U', bound=Union[ProUser, BasicUser])
 def process(cls: Type[U]):
-    cls.foo()  # E: Type[U] has no attribute "foo"
+    cls.foo()  # E: "Type[U]" has no attribute "foo"
     obj = cls()
-    cls.bar(obj)  # E: Type[U] has no attribute "bar"
+    cls.bar(obj)  # E: "Type[U]" has no attribute "bar"
     cls.mro()  # Defined in class type
-    cls.error  # E: Type[U] has no attribute "error"
+    cls.error  # E: "Type[U]" has no attribute "error"
 [builtins fixtures/classmethod.pyi]
 [out]
 
@@ -2751,7 +2751,7 @@ int.__eq__(3, 4)
 [builtins fixtures/args.pyi]
 [out]
 main:33: error: Too few arguments for "__eq__" of "int"
-main:33: error: Unsupported operand types for == ("int" and Type[int])
+main:33: error: Unsupported operand types for == ("int" and "Type[int]")
 
 [case testMroSetAfterError]
 class C(str, str):
@@ -2894,7 +2894,7 @@ class B(A):
     a = 1
     def b(self) -> None: pass
 [out]
-main:5: error: Incompatible types in assignment (expression has type "int", base class "A" defined the type as Callable[[A], None])
+main:5: error: Incompatible types in assignment (expression has type "int", base class "A" defined the type as "Callable[[A], None]")
 main:6: error: Signature of "b" incompatible with supertype "A"
 
 [case testVariableProperty]
@@ -2934,7 +2934,7 @@ class C(B):
     def m(self, a: str) -> None: pass
     n = m
 [out]
-main:5: error: Incompatible types in assignment (expression has type Callable[[str], None], base class "B" defined the type as Callable[[int], None])
+main:5: error: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "B" defined the type as "Callable[[int], None]")
 
 [case testInstanceMethodOverwriteTypevar]
 from typing import Generic, TypeVar
@@ -2978,7 +2978,7 @@ class C(B):
     n = m
 [builtins fixtures/classmethod.pyi]
 [out]
-main:7: error: Incompatible types in assignment (expression has type Callable[[str], None], base class "B" defined the type as Callable[[int], None])
+main:7: error: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "B" defined the type as "Callable[[int], None]")
 
 [case testClassSpec]
 from typing import Callable
@@ -2996,7 +2996,7 @@ class B(A):
     def c(self, a: str) -> int: pass
     b = c
 [out]
-main:6: error: Incompatible types in assignment (expression has type Callable[[str], int], base class "A" defined the type as Callable[[int], int])
+main:6: error: Incompatible types in assignment (expression has type "Callable[[str], int]", base class "A" defined the type as "Callable[[int], int]")
 
 [case testClassStaticMethod]
 class A():
@@ -3008,7 +3008,7 @@ class B(A):
     a = b
 [builtins fixtures/staticmethod.pyi]
 [out]
-main:7: error: Incompatible types in assignment (expression has type Callable[[str], None], base class "A" defined the type as Callable[[int], None])
+main:7: error: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "A" defined the type as "Callable[[int], None]")
 
 [case testClassStaticMethodIndirect]
 class A():
@@ -3021,7 +3021,7 @@ class B(A):
     c = b
 [builtins fixtures/staticmethod.pyi]
 [out]
-main:8: error: Incompatible types in assignment (expression has type Callable[[str], None], base class "A" defined the type as Callable[[int], None])
+main:8: error: Incompatible types in assignment (expression has type "Callable[[str], None]", base class "A" defined the type as "Callable[[int], None]")
 
 [case testClassStaticMethodSubclassing]
 class A:
@@ -3116,7 +3116,7 @@ class M:
 
 class A(metaclass=M): pass  # E: Metaclasses not inheriting from 'type' are not supported
 
-A.x  # E: Type[A] has no attribute "x"
+A.x  # E: "Type[A]" has no attribute "x"
 
 [case testMetaclassTypeReveal]
 from typing import Type
@@ -3188,7 +3188,7 @@ class Concrete(metaclass=Meta):
     pass
 
 reveal_type(Concrete + X())  # E: Revealed type is 'builtins.str'
-Concrete + "hello"  # E: Unsupported operand types for + (Type[Concrete] and "str")
+Concrete + "hello"  # E: Unsupported operand types for + ("Type[Concrete]" and "str")
 
 [case testMetaclassGetitem]
 class M(type):
@@ -3216,7 +3216,7 @@ from missing import M
 class A(metaclass=M):
     y = 0
 reveal_type(A.y) # E: Revealed type is 'builtins.int'
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testAnyMetaclass]
 from typing import Any
@@ -3224,7 +3224,7 @@ M = None  # type: Any
 class A(metaclass=M):
     y = 0
 reveal_type(A.y) # E: Revealed type is 'builtins.int'
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testInvalidVariableAsMetaclass]
 from typing import Any
@@ -3235,7 +3235,7 @@ class A(metaclass=M): # E: Invalid metaclass 'M'
 class B(metaclass=MM): # E: Invalid metaclass 'MM'
     y = 0
 reveal_type(A.y) # E: Revealed type is 'builtins.int'
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testAnyAsBaseOfMetaclass]
 from typing import Any, Type
@@ -3250,7 +3250,7 @@ class A(metaclass=MM):
 
 def h(a: Type[A], b: Type[object]) -> None:
     h(a, a)
-    h(b, a) # E: Argument 1 to "h" has incompatible type Type[object]; expected Type[A]
+    h(b, a) # E: Argument 1 to "h" has incompatible type "Type[object]"; expected "Type[A]"
     a.f(1) # E: Too many arguments for "f" of "A"
     reveal_type(a.y) # E: Revealed type is 'builtins.int'
 
@@ -3292,14 +3292,14 @@ reveal_type(A.g4)  # E: Revealed type is 'def () -> def () -> __main__.A'
 class B(metaclass=M):
     def foo(self): pass
 
-B.g1  # Should be error: Argument 0 to "g1" of "M" has incompatible type "B"; expected Type[A]
-B.g2  # Should be error: Argument 0 to "g2" of "M" has incompatible type "B"; expected Type[TA]
+B.g1  # Should be error: Argument 0 to "g1" of "M" has incompatible type "B"; expected "Type[A]"
+B.g2  # Should be error: Argument 0 to "g2" of "M" has incompatible type "B"; expected "Type[TA]"
 B.g3  # Should be error: Argument 0 to "g3" of "M" has incompatible type "B"; expected "TTA"
 reveal_type(B.g4)  # E: Revealed type is 'def () -> def () -> __main__.B'
 
 # 4 examples of unsoundness - instantiation, classmethod, staticmethod and ClassVar:
 
-ta: Type[A] = m  # E: Incompatible types in assignment (expression has type "M", variable has type Type[A])
+ta: Type[A] = m  # E: Incompatible types in assignment (expression has type "M", variable has type "Type[A]")
 a: A = ta()
 reveal_type(ta.g1)  # E: Revealed type is 'def () -> __main__.A'
 reveal_type(ta.g2)  # E: Revealed type is 'def () -> __main__.A*'
@@ -3307,8 +3307,8 @@ reveal_type(ta.g3)  # E: Revealed type is 'def () -> Type[__main__.A]'
 reveal_type(ta.g4)  # E: Revealed type is 'def () -> Type[__main__.A]'
 
 x: M = ta
-x.g1  # should be error: Argument 0 to "g1" of "M" has incompatible type "M"; expected Type[A]
-x.g2  # should be error: Argument 0 to "g2" of "M" has incompatible type "M"; expected Type[TA]
+x.g1  # should be error: Argument 0 to "g1" of "M" has incompatible type "M"; expected "Type[A]"
+x.g2  # should be error: Argument 0 to "g2" of "M" has incompatible type "M"; expected "Type[TA]"
 x.g3  # should be error: Argument 0 to "g3" of "M" has incompatible type "M"; expected "TTA"
 reveal_type(x.g4)  # E: Revealed type is 'def () -> __main__.M*'
 
@@ -3321,7 +3321,7 @@ class Class(metaclass=M):
     def f1(cls: Type[Class]) -> None: pass
     @classmethod
     def f2(cls: M) -> None: pass
-cl: Type[Class] = m  # E: Incompatible types in assignment (expression has type "M", variable has type Type[Class])
+cl: Type[Class] = m  # E: Incompatible types in assignment (expression has type "M", variable has type "Type[Class]")
 reveal_type(cl.f1)  # E: Revealed type is 'def ()'
 reveal_type(cl.f2)  # E: Revealed type is 'def ()'
 x1: M = cl
@@ -3329,14 +3329,14 @@ x1: M = cl
 class Static(metaclass=M):
     @staticmethod
     def f() -> None: pass
-s: Type[Static] = m  # E: Incompatible types in assignment (expression has type "M", variable has type Type[Static])
+s: Type[Static] = m  # E: Incompatible types in assignment (expression has type "M", variable has type "Type[Static]")
 reveal_type(s.f)  # E: Revealed type is 'def ()'
 x2: M = s
 
 from typing import ClassVar
 class Cvar(metaclass=M):
     x = 1  # type: ClassVar[int]
-cv: Type[Cvar] = m  # E: Incompatible types in assignment (expression has type "M", variable has type Type[Cvar])
+cv: Type[Cvar] = m  # E: Incompatible types in assignment (expression has type "M", variable has type "Type[Cvar]")
 cv.x
 x3: M = cv
 
diff --git a/test-data/unit/check-custom-plugin.test b/test-data/unit/check-custom-plugin.test
--- a/test-data/unit/check-custom-plugin.test
+++ b/test-data/unit/check-custom-plugin.test
@@ -118,7 +118,7 @@ from mypy_extensions import DefaultArg
 from m import Signal
 s: Signal[[int, DefaultArg(str, 'x')]] = Signal()
 reveal_type(s) # E: Revealed type is 'm.Signal[def (builtins.int, x: builtins.str =)]'
-s.x # E: Signal[Callable[[int, str], None]] has no attribute "x"
+s.x # E: "Signal[Callable[[int, str], None]]" has no attribute "x"
 ss: Signal[int, str] # E: Invalid "Signal" type (expected "Signal[[t, ...]]")
 [file m.py]
 from typing import TypeVar, Generic, Callable
diff --git a/test-data/unit/check-default-plugin.test b/test-data/unit/check-default-plugin.test
--- a/test-data/unit/check-default-plugin.test
+++ b/test-data/unit/check-default-plugin.test
@@ -20,7 +20,7 @@ with yield_id(1) as x:
 
 f = yield_id
 def g(x, y): pass
-f = g # E: Incompatible types in assignment (expression has type Callable[[Any, Any], Any], variable has type Callable[[T], GeneratorContextManager[T]])
+f = g # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], Any]", variable has type "Callable[[T], GeneratorContextManager[T]]")
 [typing fixtures/typing-full.pyi]
 
 [case testContextManagerWithUnspecifiedArguments]
diff --git a/test-data/unit/check-dynamic-typing.test b/test-data/unit/check-dynamic-typing.test
--- a/test-data/unit/check-dynamic-typing.test
+++ b/test-data/unit/check-dynamic-typing.test
@@ -302,7 +302,7 @@ h = None # type: Callable[[A], None]
 
 f()     # E: Too few arguments for "f"
 f(x, x) # E: Too many arguments for "f"
-g = f   # E: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type Callable[[], None])
+g = f   # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
 f(a)
 f(x)
 a = f(a)
@@ -319,10 +319,10 @@ g1 = None # type: Callable[[A], None]
 g2 = None # type: Callable[[A, A], None]
 a = None # type: A
 
-g1 = f0 # E: Incompatible types in assignment (expression has type Callable[[], Any], variable has type Callable[[A], None])
-g2 = f0 # E: Incompatible types in assignment (expression has type Callable[[], Any], variable has type Callable[[A, A], None])
-g0 = f2 # E: Incompatible types in assignment (expression has type Callable[[Any, Any], Any], variable has type Callable[[], None])
-g1 = f2 # E: Incompatible types in assignment (expression has type Callable[[Any, Any], Any], variable has type Callable[[A], None])
+g1 = f0 # E: Incompatible types in assignment (expression has type "Callable[[], Any]", variable has type "Callable[[A], None]")
+g2 = f0 # E: Incompatible types in assignment (expression has type "Callable[[], Any]", variable has type "Callable[[A, A], None]")
+g0 = f2 # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], Any]", variable has type "Callable[[], None]")
+g1 = f2 # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], Any]", variable has type "Callable[[A], None]")
 
 g0 = g0
 g2 = f2
@@ -373,9 +373,9 @@ class B: pass
 main:10: error: Too many arguments for "f01"
 main:11: error: Too few arguments for "f13"
 main:12: error: Too many arguments for "f13"
-main:13: error: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type Callable[[A, A], None])
-main:14: error: Incompatible types in assignment (expression has type Callable[[Any, Any, Any], Any], variable has type Callable[[], None])
-main:15: error: Incompatible types in assignment (expression has type Callable[[Any, Any, Any], Any], variable has type Callable[[A, A, A, A], None])
+main:13: error: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[A, A], None]")
+main:14: error: Incompatible types in assignment (expression has type "Callable[[Any, Any, Any], Any]", variable has type "Callable[[], None]")
+main:15: error: Incompatible types in assignment (expression has type "Callable[[Any, Any, Any], Any]", variable has type "Callable[[A, A, A, A], None]")
 
 [case testSkipTypeCheckingWithImplicitSignature]
 
@@ -407,9 +407,9 @@ g1 = None # type: Callable[[A], None]
 g2 = None # type: Callable[[A, A], None]
 a = None # type: A
 
-g0 = a.f # E: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type Callable[[], None])
-g2 = a.f # E: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type Callable[[A, A], None])
-a = a.f  # E: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type "A")
+g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
+g2 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[A, A], None]")
+a = a.f  # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "A")
 
 class A:
     def g(self) -> None:
@@ -434,7 +434,7 @@ g0 = None # type: Callable[[], None]
 g1 = None # type: Callable[[A], None]
 a = None # type: A
 
-g0 = a.f # E: Incompatible types in assignment (expression has type Callable[[Any], Any], variable has type Callable[[], None])
+g0 = a.f # E: Incompatible types in assignment (expression has type "Callable[[Any], Any]", variable has type "Callable[[], None]")
 
 g1 = a.f
 a = a.f(a)
@@ -485,7 +485,7 @@ class A:
   def __init__(self, a, b): pass
 [out]
 main:6: error: Too few arguments for "A"
-main:7: error: Incompatible types in assignment (expression has type Type[A], variable has type Callable[[A], A])
+main:7: error: Incompatible types in assignment (expression has type "Type[A]", variable has type "Callable[[A], A]")
 
 [case testUsingImplicitTypeObjectWithIs]
 
@@ -571,7 +571,7 @@ from typing import Any, Callable
 f1 = None # type: Callable[[Any], None]
 f2 = None # type: Callable[[Any, Any], None]
 
-f1 = f2 # E: Incompatible types in assignment (expression has type Callable[[Any, Any], None], variable has type Callable[[Any], None])
+f1 = f2 # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
 
 
 -- Overriding
diff --git a/test-data/unit/check-enum.test b/test-data/unit/check-enum.test
--- a/test-data/unit/check-enum.test
+++ b/test-data/unit/check-enum.test
@@ -325,7 +325,7 @@ main:17: error: Enum() with dict literal requires string literals
 main:18: error: Unexpected arguments to Enum()
 main:19: error: Unexpected arguments to Enum()
 main:20: error: Unexpected arguments to Enum()
-main:22: error: Type[W] has no attribute "c"
+main:22: error: "Type[W]" has no attribute "c"
 
 [case testFunctionalEnumFlag]
 from enum import Flag, IntFlag
diff --git a/test-data/unit/check-expressions.test b/test-data/unit/check-expressions.test
--- a/test-data/unit/check-expressions.test
+++ b/test-data/unit/check-expressions.test
@@ -1135,7 +1135,7 @@ b'%a' % 3
 from typing import Any, Dict
 a = None # type: Any
 ds, do, di = None, None, None # type: Dict[str, int], Dict[object, int], Dict[int, int]
-'%(a)' % 1  # E: Format requires a mapping (expression has type "int", expected type for mapping is Dict[Any, Any])
+'%(a)' % 1  # E: Format requires a mapping (expression has type "int", expected type for mapping is "Dict[Any, Any]")
 '%()d' % a
 '%()d' % ds
 '%()d' % do
@@ -1199,7 +1199,7 @@ f = lambda: ''.x
 f = lambda: ''
 [out]
 main:3: error: "str" has no attribute "x"
-main:4: error: Incompatible types in assignment (expression has type Callable[[], str], variable has type Callable[[], int])
+main:4: error: Incompatible types in assignment (expression has type "Callable[[], str]", variable has type "Callable[[], int]")
 main:4: error: Incompatible return value type (got "str", expected "int")
 
 [case testVoidLambda]
@@ -1322,7 +1322,7 @@ class B: pass
 [out]
 main:5: error: Key expression in dictionary comprehension has incompatible type "A"; expected type "B"
 main:5: error: Value expression in dictionary comprehension has incompatible type "B"; expected type "A"
-main:6: error: Incompatible types in assignment (expression has type Dict[A, B], variable has type "A")
+main:6: error: Incompatible types in assignment (expression has type "Dict[A, B]", variable has type "A")
 
 
 [case testDictionaryComprehensionWithNonDirectMapping]
@@ -1359,7 +1359,7 @@ from typing import Callable, Iterator, List
 
 a = []  # type: List[Callable[[], str]]
 b = None  # type: Iterator[Callable[[], int]]
-b = (x for x in a)  # E: Generator has incompatible item type Callable[[], str]; expected Callable[[], int]
+b = (x for x in a)  # E: Generator has incompatible item type "Callable[[], str]"; expected "Callable[[], int]"
 [builtins fixtures/list.pyi]
 
 -- Conditional expressions
@@ -1415,9 +1415,9 @@ cast(A, f)
 def f() -> None:
     pass
 [out]
-main:5: error: Unsupported left operand type for + (None)
-main:6: error: Unsupported left operand type for + (Callable[[], None])
-main:7: error: Unsupported operand types for + ("A" and Callable[[], None])
+main:5: error: Unsupported left operand type for + ("None")
+main:6: error: Unsupported left operand type for + ("Callable[[], None]")
+main:7: error: Unsupported operand types for + ("A" and "Callable[[], None]")
 
 [case testOperatorMethodWithInvalidArgCount]
 
@@ -1553,7 +1553,7 @@ d1 = dict(a=1, b=2) # type: Dict[str, int]
 d2 = dict(a=1, b='') # type: Dict[str, int] # E: Dict entry 1 has incompatible type "str": "str"; expected "str": "int"
 d3 = dict(a=1) # type: Dict[int, int] # E: Dict entry 0 has incompatible type "str": "int"; expected "int": "int"
 d4 = dict(a=1, b=1)
-d4.xyz # E: Dict[str, int] has no attribute "xyz"
+d4.xyz # E: "Dict[str, int]" has no attribute "xyz"
 d5 = dict(a=1, b='') # type: Dict[str, Any]
 [builtins fixtures/dict.pyi]
 
@@ -1567,7 +1567,7 @@ dict(undefined) # E: Name 'undefined' is not defined
 [case testDictFromList]
 from typing import Dict
 d = dict([(1, 'x'), (2, 'y')])
-d() # E: Dict[int, str] not callable
+d() # E: "Dict[int, str]" not callable
 d2 = dict([(1, 'x')]) # type: Dict[str, str] # E: List item 0 has incompatible type "Tuple[int, str]"; expected "Tuple[str, str]"
 [builtins fixtures/dict.pyi]
 
@@ -1576,10 +1576,10 @@ from typing import Dict
 it = [('x', 1)]
 
 d = dict(it, x=1)
-d() # E: Dict[str, int] not callable
+d() # E: "Dict[str, int]" not callable
 
 d2 = dict(it, x='') # E: Cannot infer type argument 2 of "dict"
-d2() # E: Dict[Any, Any] not callable
+d2() # E: "Dict[Any, Any]" not callable
 
 d3 = dict(it, x='') # type: Dict[str, int] # E: Argument 2 to "dict" has incompatible type "str"; expected "int"
 [builtins fixtures/dict.pyi]
@@ -1591,7 +1591,7 @@ dict(it, x='y') # E: Keyword argument only valid with "str" key type in call to
 
 [case testDictFromIterableAndKeywordArg3]
 d = dict([], x=1)
-d() # E: Dict[str, int] not callable
+d() # E: "Dict[str, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testDictFromIterableAndStarStarArgs]
@@ -1600,20 +1600,20 @@ it = [('x', 1)]
 
 kw = {'x': 1}
 d = dict(it, **kw)
-d() # E: Dict[str, int] not callable
+d() # E: "Dict[str, int]" not callable
 
 kw2 = {'x': ''}
 d2 = dict(it, **kw2) # E: Cannot infer type argument 2 of "dict"
-d2() # E: Dict[Any, Any] not callable
+d2() # E: "Dict[Any, Any]" not callable
 
-d3 = dict(it, **kw2) # type: Dict[str, int] # E: Argument 2 to "dict" has incompatible type **Dict[str, str]; expected "int"
+d3 = dict(it, **kw2) # type: Dict[str, int] # E: Argument 2 to "dict" has incompatible type "**Dict[str, str]"; expected "int"
 [builtins fixtures/dict.pyi]
 
 [case testDictFromIterableAndStarStarArgs2]
 it = [(1, 'x')]
 kw = {'x': 'y'}
 d = dict(it, **kw) # E: Keyword argument only valid with "str" key type in call to "dict"
-d() # E: Dict[int, str] not callable
+d() # E: "Dict[int, str]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testUserDefinedClassNamedDict]
@@ -1633,10 +1633,10 @@ class D1(dict): pass # Implicit base class Dict[Any, Any]
 D1([(1, 2)], x=1)
 class D2(Dict[T, S], Generic[T, S]): pass
 da = D2([('x', 2)], x=1)
-da() # E: D2[str, int] not callable
+da() # E: "D2[str, int]" not callable
 D2([(1, 2)], x=1) # E: Keyword argument only valid with "str" key type in call to "dict"
 db = D2(x=1)
-db() # E: D2[str, int] not callable
+db() # E: "D2[str, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testSpecialSignatureForSubclassOfDict2]
@@ -1653,7 +1653,7 @@ S = TypeVar('S')
 class D(Dict[T, S], Generic[T, S]):
     def __init__(self, x: S, y: T) -> None: pass
 d = D(1, y='')
-d() # E: D[str, int] not callable
+d() # E: "D[str, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testRevealType]
@@ -1708,7 +1708,7 @@ None == None
 [builtins fixtures/ops.pyi]
 
 [case testLtNone]
-None < None  # E: Unsupported left operand type for < (None)
+None < None  # E: Unsupported left operand type for < ("None")
 [builtins fixtures/ops.pyi]
 
 [case testDictWithStarExpr]
@@ -1723,8 +1723,8 @@ a = {'a': 1}
 b = {'z': 26, **a}
 c = {**b}
 d = {**a, **b, 'c': 3}
-e = {1: 'a', **a}  # E: Argument 1 to "update" of "dict" has incompatible type Dict[str, int]; expected Mapping[int, str]
-f = {**b}  # type: Dict[int, int]  # E: List item 0 has incompatible type Dict[str, int]; expected Mapping[int, int]
+e = {1: 'a', **a}  # E: Argument 1 to "update" of "dict" has incompatible type "Dict[str, int]"; expected "Mapping[int, str]"
+f = {**b}  # type: Dict[int, int]  # E: List item 0 has incompatible type "Dict[str, int]"; expected "Mapping[int, int]"
 [builtins fixtures/dict.pyi]
 
 [case testDictIncompatibleTypeErrorMessage]
@@ -1733,7 +1733,7 @@ from typing import Dict, Callable
 def things() -> int:
     return 42
 
-stuff: Dict[int, Callable[[], str]] = {  # E: Dict entry 0 has incompatible type "int": Callable[[], int]; expected "int": Callable[[], str]
+stuff: Dict[int, Callable[[], str]] = {  # E: Dict entry 0 has incompatible type "int": "Callable[[], int]"; expected "int": "Callable[[], str]"
     1: things
 }
 [builtins fixtures/dict.pyi]
diff --git a/test-data/unit/check-flags.test b/test-data/unit/check-flags.test
--- a/test-data/unit/check-flags.test
+++ b/test-data/unit/check-flags.test
@@ -265,7 +265,7 @@ reveal_type(f() or no_return())  # E: Revealed type is 'builtins.int'
 # flags: --warn-no-return
 from mypy_extensions import NoReturn
 
-x = 0  # type: NoReturn  # E: Incompatible types in assignment (expression has type "int", variable has type NoReturn)
+x = 0  # type: NoReturn  # E: Incompatible types in assignment (expression has type "int", variable has type "NoReturn")
 [builtins fixtures/dict.pyi]
 
 [case testNoReturnImportFromTyping]
@@ -281,7 +281,7 @@ def no_return() -> NoReturn: pass
 def f() -> NoReturn:
   no_return()
 
-x: NoReturn = 0 # E: Incompatible types in assignment (expression has type "int", variable has type NoReturn)
+x: NoReturn = 0 # E: Incompatible types in assignment (expression has type "int", variable has type "NoReturn")
 [builtins fixtures/dict.pyi]
 
 [case testShowErrorContextFunction]
@@ -462,7 +462,7 @@ x = 0
 x = None
 [file optional.py]
 x = 0
-x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+x = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 
 [file mypy.ini]
 [[mypy]
@@ -486,10 +486,10 @@ f(optional_int)  # optional ints can be used as ints in this file
 [file optional.py]
 import standard
 def f(x: int) -> None: pass
-standard.an_int = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+standard.an_int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 standard.optional_int = None  # OK -- explicitly declared as optional
 f(standard.an_int)  # ints can be used as ints
-f(standard.optional_int)  # E: Argument 1 to "f" has incompatible type None; expected "int"
+f(standard.optional_int)  # E: Argument 1 to "f" has incompatible type "None"; expected "int"
 
 [file mypy.ini]
 [[mypy]
@@ -603,9 +603,9 @@ def foo(l: List[Unchecked]) -> List[Unchecked]:
     return l
 [builtins fixtures/list.pyi]
 [out]
-main:5: error: Return type becomes List[Any] due to an unfollowed import
-main:5: error: Argument 1 to "foo" becomes List[Any] due to an unfollowed import
-main:6: error: Type of variable becomes List[Any] due to an unfollowed import
+main:5: error: Return type becomes "List[Any]" due to an unfollowed import
+main:5: error: Argument 1 to "foo" becomes "List[Any]" due to an unfollowed import
+main:6: error: Type of variable becomes "List[Any]" due to an unfollowed import
 
 [case testDisallowImplicitAnyInherit]
 # flags: --ignore-missing-imports --disallow-any=unimported
@@ -615,7 +615,7 @@ from typing import List
 class C(Unchecked): # E: Base type Unchecked becomes "Any" due to an unfollowed import
     pass
 
-class A(List[Unchecked]): # E: Base type becomes List[Any] due to an unfollowed import
+class A(List[Unchecked]): # E: Base type becomes "List[Any]" due to an unfollowed import
     pass
 [builtins fixtures/list.pyi]
 
@@ -626,7 +626,7 @@ from typing import List
 
 X = List[Unchecked]
 
-def f(x: X) -> None:  # E: Argument 1 to "f" becomes List[Any] due to an unfollowed import
+def f(x: X) -> None:  # E: Argument 1 to "f" becomes "List[Any]" due to an unfollowed import
     pass
 [builtins fixtures/list.pyi]
 
@@ -637,7 +637,7 @@ from typing import List, cast
 
 
 foo = [1, 2, 3]
-cast(List[Unchecked], foo)  # E: Target type of cast becomes List[Any] due to an unfollowed import
+cast(List[Unchecked], foo)  # E: Target type of cast becomes "List[Any]" due to an unfollowed import
 cast(Unchecked, foo)  # E: Target type of cast becomes "Any" due to an unfollowed import
 [builtins fixtures/list.pyi]
 
@@ -661,7 +661,7 @@ T = TypeVar('T', Unchecked, List[Unchecked], str)
 [builtins fixtures/list.pyi]
 [out]
 main:5: error: Constraint 1 becomes "Any" due to an unfollowed import
-main:5: error: Constraint 2 becomes List[Any] due to an unfollowed import
+main:5: error: Constraint 2 becomes "List[Any]" due to an unfollowed import
 
 [case testDisallowImplicitAnyNewType]
 # flags: --ignore-missing-imports --disallow-any=unimported
@@ -669,7 +669,7 @@ from typing import NewType, List
 from missing import Unchecked
 
 Baz = NewType('Baz', Unchecked)  # E: Argument 2 to NewType(...) must be subclassable (got Any)
-Bar = NewType('Bar', List[Unchecked])  # E: Argument 2 to NewType(...) becomes List[Any] due to an unfollowed import
+Bar = NewType('Bar', List[Unchecked])  # E: Argument 2 to NewType(...) becomes "List[Any]" due to an unfollowed import
 
 [builtins fixtures/list.pyi]
 
@@ -683,7 +683,7 @@ def foo(f: Callable[[], Unchecked]) -> Tuple[Unchecked]:
 [builtins fixtures/list.pyi]
 [out]
 main:5: error: Return type becomes "Tuple[Any]" due to an unfollowed import
-main:5: error: Argument 1 to "foo" becomes Callable[[], Any] due to an unfollowed import
+main:5: error: Argument 1 to "foo" becomes "Callable[[], Any]" due to an unfollowed import
 
 [case testDisallowImplicitAnySubclassingExplicitAny]
 # flags: --ignore-missing-imports --disallow-any=unimported --disallow-subclassing-any
@@ -720,7 +720,7 @@ from mypy_extensions import TypedDict
 from typing import List
 from x import Unchecked
 
-M = TypedDict('M', {'x': str, 'y': List[Unchecked]})  # E: Type of a TypedDict key becomes List[Any] due to an unfollowed import
+M = TypedDict('M', {'x': str, 'y': List[Unchecked]})  # E: Type of a TypedDict key becomes "List[Any]" due to an unfollowed import
 
 def f(m: M) -> M: pass  # no error
 [builtins fixtures/dict.pyi]
@@ -770,7 +770,7 @@ def d(f) -> Callable[..., None]:
     return f
 
 @d
-def g(i: int, s: str) -> None: pass  # E: Type of decorated function contains type "Any" (Callable[..., None])
+def g(i: int, s: str) -> None: pass  # E: Type of decorated function contains type "Any" ("Callable[..., None]")
 
 [builtins fixtures/list.pyi]
 [case testDisallowAnyDecoratedNonexistentDecorator]
@@ -790,13 +790,13 @@ def d2(f) -> Callable[[int], List[Any]]: pass
 def d3(f) -> Callable[[Any], List[str]]: pass
 
 @d
-def f(i: int, s: str) -> None:  # E: Type of decorated function contains type "Any" (Callable[[int, Any], Any])
+def f(i: int, s: str) -> None:  # E: Type of decorated function contains type "Any" ("Callable[[int, Any], Any]")
     pass
 @d2
-def g(i: int) -> None:  # E: Type of decorated function contains type "Any" (Callable[[int], List[Any]])
+def g(i: int) -> None:  # E: Type of decorated function contains type "Any" ("Callable[[int], List[Any]]")
     pass
 @d3
-def h(i: int) -> None:  # E: Type of decorated function contains type "Any" (Callable[[Any], List[str]])
+def h(i: int) -> None:  # E: Type of decorated function contains type "Any" ("Callable[[Any], List[str]]")
     pass
 [builtins fixtures/list.pyi]
 
@@ -883,9 +883,9 @@ def g(s: List[Any]) -> None:
 
 f(0)
 
-# type of list below is inferred with expected type of List[Any], so that becomes it's type
+# type of list below is inferred with expected type of "List[Any]", so that becomes it's type
 # instead of List[str]
-g([''])  # E: Expression type contains "Any" (has type List[Any])
+g([''])  # E: Expression type contains "Any" (has type "List[Any]")
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExprAllowsAnyInCast]
@@ -916,8 +916,8 @@ n = Foo().g  # type: Any  # E: Expression has type "Any"
 from typing import List
 
 l: List = []
-l.append(1)  # E: Expression type contains "Any" (has type List[Any])
-k = l[0]  # E: Expression type contains "Any" (has type List[Any])  # E: Expression has type "Any"
+l.append(1)  # E: Expression type contains "Any" (has type "List[Any]")
+k = l[0]  # E: Expression type contains "Any" (has type "List[Any]")  # E: Expression has type "Any"
 [builtins fixtures/list.pyi]
 
 [case testDisallowAnyExprTypeVar]
diff --git a/test-data/unit/check-functions.test b/test-data/unit/check-functions.test
--- a/test-data/unit/check-functions.test
+++ b/test-data/unit/check-functions.test
@@ -65,10 +65,10 @@ class B(A): pass
 f = None # type: Callable[[B], A]
 g = None # type: Callable[[A], A]  # subtype of f
 h = None # type: Callable[[B], B]  # subtype of f
-g = h  # E: Incompatible types in assignment (expression has type Callable[[B], B], variable has type Callable[[A], A])
-h = f  # E: Incompatible types in assignment (expression has type Callable[[B], A], variable has type Callable[[B], B])
-h = g  # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[B], B])
-g = f  # E: Incompatible types in assignment (expression has type Callable[[B], A], variable has type Callable[[A], A])
+g = h  # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[A], A]")
+h = f  # E: Incompatible types in assignment (expression has type "Callable[[B], A]", variable has type "Callable[[B], B]")
+h = g  # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[B], B]")
+g = f  # E: Incompatible types in assignment (expression has type "Callable[[B], A]", variable has type "Callable[[A], A]")
 f = g
 f = h
 f = f
@@ -79,13 +79,13 @@ h = h
 
 def l(x) -> None: ...
 def r(__, *, x) -> None: ...
-r = l # E: Incompatible types in assignment (expression has type Callable[[Any], None], variable has type Callable[[Any, NamedArg(Any, 'x')], None])
+r = l # E: Incompatible types in assignment (expression has type "Callable[[Any], None]", variable has type "Callable[[Any, NamedArg(Any, 'x')], None]")
 
 [case testSubtypingFunctionsRequiredLeftArgNotPresent]
 
 def l(x, y) -> None: ...
 def r(x) -> None: ...
-r = l # E: Incompatible types in assignment (expression has type Callable[[Any, Any], None], variable has type Callable[[Any], None])
+r = l # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], None]", variable has type "Callable[[Any], None]")
 
 [case testSubtypingFunctionsImplicitNames]
 from typing import Any
@@ -115,10 +115,10 @@ hh = h
 ff = gg
 ff_nonames = ff
 ff_nonames = f_nonames # reset
-ff = ff_nonames # E: Incompatible types in assignment (expression has type Callable[[int, str], None], variable has type Callable[[Arg(int, 'a'), Arg(str, 'b')], None])
+ff = ff_nonames # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "Callable[[Arg(int, 'a'), Arg(str, 'b')], None]")
 ff = f # reset
-gg = ff # E: Incompatible types in assignment (expression has type Callable[[Arg(int, 'a'), Arg(str, 'b')], None], variable has type Callable[[Arg(int, 'a'), DefaultArg(str, 'b')], None])
-gg = hh # E: Incompatible types in assignment (expression has type Callable[[Arg(int, 'aa'), DefaultArg(str, 'b')], None], variable has type Callable[[Arg(int, 'a'), DefaultArg(str, 'b')], None])
+gg = ff # E: Incompatible types in assignment (expression has type "Callable[[Arg(int, 'a'), Arg(str, 'b')], None]", variable has type "Callable[[Arg(int, 'a'), DefaultArg(str, 'b')], None]")
+gg = hh # E: Incompatible types in assignment (expression has type "Callable[[Arg(int, 'aa'), DefaultArg(str, 'b')], None]", variable has type "Callable[[Arg(int, 'a'), DefaultArg(str, 'b')], None]")
 
 [case testSubtypingFunctionsArgsKwargs]
 from typing import Any, Callable
@@ -144,7 +144,7 @@ ee_var = everything
 ee_var = everywhere
 
 ee_var = specific_1 # The difference between Callable[..., blah] and one with a *args: Any, **kwargs: Any is that the ... goes loosely both ways.
-ee_def = specific_1 # E: Incompatible types in assignment (expression has type Callable[[int, str], None], variable has type Callable[[VarArg(Any), KwArg(Any)], None])
+ee_def = specific_1 # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "Callable[[VarArg(Any), KwArg(Any)], None]")
 
 [builtins fixtures/dict.pyi]
 
@@ -175,7 +175,7 @@ ff = f
 gg = g
 
 ff = g
-gg = f # E: Incompatible types in assignment (expression has type Callable[[int, str], None], variable has type Callable[[Arg(int, 'a'), Arg(str, 'b')], None])
+gg = f # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "Callable[[Arg(int, 'a'), Arg(str, 'b')], None]")
 
 [case testLackOfNamesFastparse]
 
@@ -187,15 +187,15 @@ ff = f
 gg = g
 
 ff = g
-gg = f # E: Incompatible types in assignment (expression has type Callable[[int, str], None], variable has type Callable[[Arg(int, 'a'), Arg(str, 'b')], None])
+gg = f # E: Incompatible types in assignment (expression has type "Callable[[int, str], None]", variable has type "Callable[[Arg(int, 'a'), Arg(str, 'b')], None]")
 
 [case testFunctionTypeCompatibilityWithOtherTypes]
 from typing import Callable
 f = None # type: Callable[[], None]
 a, o = None, None # type: (A, object)
-a = f   # E: Incompatible types in assignment (expression has type Callable[[], None], variable has type "A")
-f = a   # E: Incompatible types in assignment (expression has type "A", variable has type Callable[[], None])
-f = o   # E: Incompatible types in assignment (expression has type "object", variable has type Callable[[], None])
+a = f   # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "A")
+f = a   # E: Incompatible types in assignment (expression has type "A", variable has type "Callable[[], None]")
+f = o   # E: Incompatible types in assignment (expression has type "object", variable has type "Callable[[], None]")
 f = f() # E: Function does not return a value
 
 f = f
@@ -208,7 +208,7 @@ class A: pass
 from typing import Callable
 f = None # type: Callable[[], None]
 g = None # type: Callable[[], object]
-f = g  # E: Incompatible types in assignment (expression has type Callable[[], object], variable has type Callable[[], None])
+f = g  # E: Incompatible types in assignment (expression has type "Callable[[], object]", variable has type "Callable[[], None]")
 g = f  # OK
 
 f = f
@@ -219,9 +219,9 @@ from typing import Callable
 f = None # type: Callable[[A, A], None]
 g = None # type: Callable[[A, B], None]
 h = None # type: Callable[[B, B], None]
-f = g  # E: Incompatible types in assignment (expression has type Callable[[A, B], None], variable has type Callable[[A, A], None])
-f = h  # E: Incompatible types in assignment (expression has type Callable[[B, B], None], variable has type Callable[[A, A], None])
-g = h  # E: Incompatible types in assignment (expression has type Callable[[B, B], None], variable has type Callable[[A, B], None])
+f = g  # E: Incompatible types in assignment (expression has type "Callable[[A, B], None]", variable has type "Callable[[A, A], None]")
+f = h  # E: Incompatible types in assignment (expression has type "Callable[[B, B], None]", variable has type "Callable[[A, A], None]")
+g = h  # E: Incompatible types in assignment (expression has type "Callable[[B, B], None]", variable has type "Callable[[A, B], None]")
 g = f
 h = f
 h = g
@@ -238,10 +238,10 @@ f = None # type: Callable[[], None]
 g = None # type: Callable[[A], None]
 h = None # type: Callable[[A, A], None]
 
-f = g   # E: Incompatible types in assignment (expression has type Callable[[A], None], variable has type Callable[[], None])
-f = h   # E: Incompatible types in assignment (expression has type Callable[[A, A], None], variable has type Callable[[], None])
-h = f   # E: Incompatible types in assignment (expression has type Callable[[], None], variable has type Callable[[A, A], None])
-h = g   # E: Incompatible types in assignment (expression has type Callable[[A], None], variable has type Callable[[A, A], None])
+f = g   # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[], None]")
+f = h   # E: Incompatible types in assignment (expression has type "Callable[[A, A], None]", variable has type "Callable[[], None]")
+h = f   # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "Callable[[A, A], None]")
+h = g   # E: Incompatible types in assignment (expression has type "Callable[[A], None]", variable has type "Callable[[A, A], None]")
 
 f = f
 g = g
@@ -255,8 +255,8 @@ class A: pass
 t = None # type: type
 a = None # type: A
 
-a = A # E: Incompatible types in assignment (expression has type Type[A], variable has type "A")
-t = f # E: Incompatible types in assignment (expression has type Callable[[], None], variable has type "type")
+a = A # E: Incompatible types in assignment (expression has type "Type[A]", variable has type "A")
+t = f # E: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "type")
 t = A
 
 class A:
@@ -272,7 +272,7 @@ f = None # type: Callable[[AA], A]
 g = None # type: Callable[[B], B]
 h = None # type: Callable[[A], AA]
 
-h = i  # E: Incompatible types in assignment (expression has type overloaded function, variable has type Callable[[A], AA])
+h = i  # E: Incompatible types in assignment (expression has type overloaded function, variable has type "Callable[[A], AA]")
 f = j
 
 f = i
@@ -311,7 +311,7 @@ a, b, c = None, None, None # type: (A, B, C)
 b = f(a)  # E: Incompatible types in assignment (expression has type "A", variable has type "B")
 a = f(b)  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
 b = f(c)  # E: Incompatible types in assignment (expression has type "C", variable has type "B")
-g4 = f    # E: Incompatible types in assignment (expression has type overloaded function, variable has type Callable[[A], B])
+g4 = f    # E: Incompatible types in assignment (expression has type overloaded function, variable has type "Callable[[A], B]")
 
 g1 = f
 g2 = f
@@ -335,10 +335,10 @@ def f(x: C) -> C: pass
 from typing import Any, Callable, List
 def f(fields: List[Callable[[Any], Any]]): pass
 class C: pass
-f([C])  # E: List item 0 has incompatible type Type[C]; expected Callable[[Any], Any]
+f([C])  # E: List item 0 has incompatible type "Type[C]"; expected "Callable[[Any], Any]"
 class D:
     def __init__(self, a, b): pass
-f([D])  # E: List item 0 has incompatible type Type[D]; expected Callable[[Any], Any]
+f([D])  # E: List item 0 has incompatible type "Type[D]"; expected "Callable[[Any], Any]"
 [builtins fixtures/list.pyi]
 
 [case testSubtypingTypeTypeAsCallable]
@@ -353,7 +353,7 @@ from typing import Callable, Type
 class A: pass
 x = None  # type: Callable[..., A]
 y = None  # type: Type[A]
-y = x  # E: Incompatible types in assignment (expression has type Callable[..., A], variable has type Type[A])
+y = x  # E: Incompatible types in assignment (expression has type "Callable[..., A]", variable has type "Type[A]")
 
 -- Default argument values
 -- -----------------------
@@ -555,7 +555,7 @@ class A(Generic[t]):
     g = f
 a = None # type: A[B]
 a.g(B())
-a.g(a)   # E: Argument 1 has incompatible type A[B]; expected "B"
+a.g(a)   # E: Argument 1 has incompatible type "A[B]"; expected "B"
 
 [case testInvalidMethodAsDataAttributeInGenericClass]
 from typing import Any, TypeVar, Generic, Callable
@@ -676,8 +676,8 @@ def f() -> None:
         g(1)
         g.x # E
 [out]
-main:7: error: Callable[..., Any] has no attribute "x"
-main:11: error: Callable[..., Any] has no attribute "x"
+main:7: error: "Callable[..., Any]" has no attribute "x"
+main:11: error: "Callable[..., Any]" has no attribute "x"
 
 [case testNestedGenericFunctions]
 from typing import TypeVar
@@ -785,7 +785,7 @@ f(None) # E: Too many arguments for "f"
 from typing import Any, Callable
 def dec1(f: Callable[[Any], None]) -> Callable[[], None]: pass
 def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass
-@dec1 # E: Argument 1 to "dec2" has incompatible type Callable[[Any], Any]; expected Callable[[Any, Any], None]
+@dec1 # E: Argument 1 to "dec2" has incompatible type "Callable[[Any], Any]"; expected "Callable[[Any, Any], None]"
 @dec2
 def f(x): pass
 
@@ -793,7 +793,7 @@ def f(x): pass
 from typing import Any, Callable
 def dec1(f: Callable[[Any, Any], None]) -> Callable[[], None]: pass
 def dec2(f: Callable[[Any, Any], None]) -> Callable[[Any], None]: pass
-@dec1 # E: Argument 1 to "dec1" has incompatible type Callable[[Any], None]; expected Callable[[Any, Any], None]
+@dec1 # E: Argument 1 to "dec1" has incompatible type "Callable[[Any], None]"; expected "Callable[[Any, Any], None]"
 @dec2
 def f(x, y): pass
 
@@ -1322,7 +1322,7 @@ def g() -> None:
 def g(): pass
 f = g
 if g():
-    def f(x): pass  # E: Incompatible redefinition (redefinition with type Callable[[Any], Any], original type Callable[[], Any])
+    def f(x): pass  # E: Incompatible redefinition (redefinition with type "Callable[[Any], Any]", original type "Callable[[], Any]")
 
 [case testRedefineFunctionDefinedAsVariableWithVariance1]
 class B: pass
@@ -1517,7 +1517,7 @@ 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   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  # 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  # 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  # 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  # E: Value of type "int" is not indexable  # E: "Arg" gets multiple values for keyword argument "name"
@@ -1560,7 +1560,7 @@ def f2(*args, **kwargs) -> int: pass
 d(f1)
 e(f2)
 d(f2)
-e(f1)  # E: Argument 1 to "e" has incompatible type Callable[[VarArg(Any)], int]; expected Callable[[VarArg(Any), KwArg(Any)], int]
+e(f1)  # E: Argument 1 to "e" has incompatible type "Callable[[VarArg(Any)], int]"; expected "Callable[[VarArg(Any), KwArg(Any)], int]"
 
 [builtins fixtures/dict.pyi]
 
@@ -1681,12 +1681,12 @@ def isf_unnamed(__i: int, __s: str) -> str:
 
 int_str_fun = isf
 int_str_fun = isf_unnamed
-int_named_str_fun = isf_unnamed # E: Incompatible types in assignment (expression has type Callable[[int, str], str], variable has type Callable[[int, Arg(str, 's')], str])
+int_named_str_fun = isf_unnamed # E: Incompatible types in assignment (expression has type "Callable[[int, str], str]", variable has type "Callable[[int, Arg(str, 's')], str]")
 int_opt_str_fun = iosf
 int_str_fun = iosf
-int_opt_str_fun = isf # E: Incompatible types in assignment (expression has type Callable[[Arg(int, 'ii'), Arg(str, 'ss')], str], variable has type Callable[[int, DefaultArg(str)], str])
+int_opt_str_fun = isf # E: Incompatible types in assignment (expression has type "Callable[[Arg(int, 'ii'), Arg(str, 'ss')], str]", variable has type "Callable[[int, DefaultArg(str)], str]")
 
-int_named_str_fun = isf # E: Incompatible types in assignment (expression has type Callable[[Arg(int, 'ii'), Arg(str, 'ss')], str], variable has type Callable[[int, Arg(str, 's')], str])
+int_named_str_fun = isf # E: Incompatible types in assignment (expression has type "Callable[[Arg(int, 'ii'), Arg(str, 'ss')], str]", variable has type "Callable[[int, Arg(str, 's')], str]")
 int_named_str_fun = iosf
 
 [builtins fixtures/dict.pyi]
@@ -1718,7 +1718,7 @@ f(x=4) + '' # E: Unsupported operand types for + ("int" and "str")
 [case testCallableWithArbitraryArgsInErrorMessage]
 from typing import Callable
 def f(x: Callable[..., int]) -> None:
-    x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type Callable[..., int])
+    x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[..., int]")
 [out]
 
 [case testCallableWithArbitraryArgsInGenericFunction]
@@ -1740,7 +1740,7 @@ def g4(*, y: int) -> str: pass
 f(g1)
 f(g2)
 f(g3)
-f(g4) # E: Argument 1 to "f" has incompatible type Callable[[NamedArg(int, 'y')], str]; expected Callable[..., int]
+f(g4) # E: Argument 1 to "f" has incompatible type "Callable[[NamedArg(int, 'y')], str]"; expected "Callable[..., int]"
 
 [case testCallableWithArbitraryArgsSubtypingWithGenericFunc]
 from typing import Callable, TypeVar
@@ -1773,7 +1773,7 @@ f(x=1, y="hello", z=[])
 from typing import Dict
 def f(x, **kwargs): # type: (...) -> None
     success_dict_type = kwargs # type: Dict[str, str]
-    failure_dict_type = kwargs # type: Dict[int, str] # E: Incompatible types in assignment (expression has type Dict[str, Any], variable has type Dict[int, str])
+    failure_dict_type = kwargs # type: Dict[int, str] # E: Incompatible types in assignment (expression has type "Dict[str, Any]", variable has type "Dict[int, str]")
 f(1, thing_in_kwargs=["hey"])
 [builtins fixtures/dict.pyi]
 [out]
@@ -1782,7 +1782,7 @@ f(1, thing_in_kwargs=["hey"])
 from typing import Tuple, Any
 def f(x, *args): # type: (...) -> None
     success_tuple_type = args # type: Tuple[Any, ...]
-    fail_tuple_type = args # type: None # E: Incompatible types in assignment (expression has type Tuple[Any, ...], variable has type None)
+    fail_tuple_type = args # type: None # E: Incompatible types in assignment (expression has type "Tuple[Any, ...]", variable has type "None")
 f(1, "hello")
 [builtins fixtures/tuple.pyi]
 [out]
@@ -1869,8 +1869,8 @@ def g(x, y): pass
 def h(x): pass
 def j(y) -> Any: pass
 f = h
-f = j # E: Incompatible types in assignment (expression has type Callable[[Arg(Any, 'y')], Any], variable has type Callable[[Arg(Any, 'x')], Any])
-f = g # E: Incompatible types in assignment (expression has type Callable[[Any, Any], Any], variable has type Callable[[Any], Any])
+f = j # E: Incompatible types in assignment (expression has type "Callable[[Arg(Any, 'y')], Any]", variable has type "Callable[[Arg(Any, 'x')], Any]")
+f = g # E: Incompatible types in assignment (expression has type "Callable[[Any, Any], Any]", variable has type "Callable[[Any], Any]")
 
 [case testRedefineFunction2]
 def f() -> None: pass
@@ -2111,23 +2111,23 @@ def fn(
 from typing import Union, Dict, List
 def f() -> List[Union[str, int]]:
     x = ['a']
-    return x # E: Incompatible return value type (got List[str], expected List[Union[str, int]]) \
-# N: Perhaps you need a type annotation for "x"? Suggestion: List[Union[str, int]]
+    return x # E: Incompatible return value type (got "List[str]", expected "List[Union[str, int]]") \
+# N: Perhaps you need a type annotation for "x"? Suggestion: "List[Union[str, int]]"
 
 def g() -> Dict[str, Union[str, int]]:
     x = {'a': 'a'}
-    return x # E: Incompatible return value type (got Dict[str, str], expected Dict[str, Union[str, int]]) \
-# N: Perhaps you need a type annotation for "x"? Suggestion: Dict[str, Union[str, int]]
+    return x # E: Incompatible return value type (got "Dict[str, str]", expected "Dict[str, Union[str, int]]") \
+# N: Perhaps you need a type annotation for "x"? Suggestion: "Dict[str, Union[str, int]]"
 
 def h() -> Dict[Union[str, int], str]:
     x = {'a': 'a'}
-    return x # E: Incompatible return value type (got Dict[str, str], expected Dict[Union[str, int], str]) \
-# N: Perhaps you need a type annotation for "x"? Suggestion: Dict[Union[str, int], str]
+    return x # E: Incompatible return value type (got "Dict[str, str]", expected "Dict[Union[str, int], str]") \
+# N: Perhaps you need a type annotation for "x"? Suggestion: "Dict[Union[str, int], str]"
 
 def i() -> List[Union[int, float]]:
     x: List[int] = [1]
-    return x # E: Incompatible return value type (got List[int], expected List[Union[int, float]]) \
-# N: Perhaps you need a type annotation for "x"? Suggestion: List[Union[int, float]]
+    return x # E: Incompatible return value type (got "List[int]", expected "List[Union[int, float]]") \
+# N: Perhaps you need a type annotation for "x"? Suggestion: "List[Union[int, float]]"
 
 [builtins fixtures/dict.pyi]
 
@@ -2135,11 +2135,11 @@ def i() -> List[Union[int, float]]:
 from typing import Union, List
 def f() -> List[Union[int, float]]:
     x = ['a']
-    return x # E: Incompatible return value type (got List[str], expected List[Union[int, float]])
+    return x # E: Incompatible return value type (got "List[str]", expected "List[Union[int, float]]")
 
 def g() -> List[Union[str, int]]:
     x = ('a', 2)
-    return x # E: Incompatible return value type (got "Tuple[str, int]", expected List[Union[str, int]])
+    return x # E: Incompatible return value type (got "Tuple[str, int]", expected "List[Union[str, int]]")
 
 [builtins fixtures/list.pyi]
 
@@ -2147,7 +2147,7 @@ def g() -> List[Union[str, int]]:
 from typing import Union, Dict, List
 def f() -> Dict[str, Union[str, int]]:
     x = {'a': 'a', 'b': 2}
-    return x # E: Incompatible return value type (got Dict[str, object], expected Dict[str, Union[str, int]])
+    return x # E: Incompatible return value type (got "Dict[str, object]", expected "Dict[str, Union[str, int]]")
 
 def g() -> Dict[str, Union[str, int]]:
     x: Dict[str, Union[str, int]] = {'a': 'a', 'b': 2}
@@ -2155,7 +2155,7 @@ def g() -> Dict[str, Union[str, int]]:
 
 def h() -> List[Union[str, int]]:
     x = ['a', 2]
-    return x # E: Incompatible return value type (got List[object], expected List[Union[str, int]])
+    return x # E: Incompatible return value type (got "List[object]", expected "List[Union[str, int]]")
 
 def i() -> List[Union[str, int]]:
     x: List[Union[str, int]] = ['a', 2]
diff --git a/test-data/unit/check-generic-subtyping.test b/test-data/unit/check-generic-subtyping.test
--- a/test-data/unit/check-generic-subtyping.test
+++ b/test-data/unit/check-generic-subtyping.test
@@ -13,9 +13,9 @@ ac = None # type: A[C]
 ad = None # type: A[D]
 b = None # type: B
 
-b = ad # E: Incompatible types in assignment (expression has type A[D], variable has type "B")
-ad = b # E: Incompatible types in assignment (expression has type "B", variable has type A[D])
-b = ac # E: Incompatible types in assignment (expression has type A[C], variable has type "B")
+b = ad # E: Incompatible types in assignment (expression has type "A[D]", variable has type "B")
+ad = b # E: Incompatible types in assignment (expression has type "B", variable has type "A[D]")
+b = ac # E: Incompatible types in assignment (expression has type "A[C]", variable has type "B")
 
 b = b
 ac = b
@@ -32,10 +32,10 @@ a = None # type: A
 bc = None # type: B[C]
 bd = None # type: B[D]
 
-bc = bd # E: Incompatible types in assignment (expression has type B[D], variable has type B[C])
-bd = bc # E: Incompatible types in assignment (expression has type B[C], variable has type B[D])
-bc = a  # E: Incompatible types in assignment (expression has type "A", variable has type B[C])
-bd = a  # E: Incompatible types in assignment (expression has type "A", variable has type B[D])
+bc = bd # E: Incompatible types in assignment (expression has type "B[D]", variable has type "B[C]")
+bd = bc # E: Incompatible types in assignment (expression has type "B[C]", variable has type "B[D]")
+bc = a  # E: Incompatible types in assignment (expression has type "A", variable has type "B[C]")
+bd = a  # E: Incompatible types in assignment (expression has type "A", variable has type "B[D]")
 
 a = bc
 a = bd
@@ -54,10 +54,10 @@ ad = None # type: A[D]
 bcc = None # type: B[C, C]
 bdc = None # type: B[D, C]
 
-ad = bcc # E: Incompatible types in assignment (expression has type B[C, C], variable has type A[D])
-ad = bdc # E: Incompatible types in assignment (expression has type B[D, C], variable has type A[D])
-bcc = ac # E: Incompatible types in assignment (expression has type A[C], variable has type B[C, C])
-bdc = ac # E: Incompatible types in assignment (expression has type A[C], variable has type B[D, C])
+ad = bcc # E: Incompatible types in assignment (expression has type "B[C, C]", variable has type "A[D]")
+ad = bdc # E: Incompatible types in assignment (expression has type "B[D, C]", variable has type "A[D]")
+bcc = ac # E: Incompatible types in assignment (expression has type "A[C]", variable has type "B[C, C]")
+bdc = ac # E: Incompatible types in assignment (expression has type "A[C]", variable has type "B[D, C]")
 
 bcc = bcc
 bdc = bdc
@@ -82,8 +82,8 @@ cef = None # type: C[E, F]
 cff = None # type: C[F, F]
 cfe = None # type: C[F, E]
 
-ae = cef # E: Incompatible types in assignment (expression has type C[E, F], variable has type A[A[E]])
-af = cfe # E: Incompatible types in assignment (expression has type C[F, E], variable has type A[A[F]])
+ae = cef # E: Incompatible types in assignment (expression has type "C[E, F]", variable has type "A[A[E]]")
+af = cfe # E: Incompatible types in assignment (expression has type "C[F, E]", variable has type "A[A[F]]")
 
 ae = cfe
 af = cef
@@ -280,7 +280,7 @@ a = None # type: A
 bc = None # type: B[C]
 bd = None # type: B[D]
 
-a = bc # E: Incompatible types in assignment (expression has type B[C], variable has type "A")
+a = bc # E: Incompatible types in assignment (expression has type "B[C]", variable has type "A")
 bc = a
 bd = a
 
@@ -305,8 +305,8 @@ a = None # type: A
 c = None # type: C
 bc = None # type: B[C]
 
-a.x = c # E: Incompatible types in assignment (expression has type "C", variable has type B[Any])
-a.f(c)  # E: Argument 1 to "f" of "B" has incompatible type "C"; expected B[Any]
+a.x = c # E: Incompatible types in assignment (expression has type "C", variable has type "B[Any]")
+a.f(c)  # E: Argument 1 to "f" of "B" has incompatible type "C"; expected "B[Any]"
 a.x = bc
 a.f(bc)
 [out]
@@ -325,8 +325,8 @@ class B(Generic[T]):
 
 class A(B):
   def g(self) -> None:
-    self.x = c # E: Incompatible types in assignment (expression has type "C", variable has type B[Any])
-    self.f(c)  # E: Argument 1 to "f" of "B" has incompatible type "C"; expected B[Any]
+    self.x = c # E: Incompatible types in assignment (expression has type "C", variable has type "B[Any]")
+    self.f(c)  # E: Argument 1 to "f" of "B" has incompatible type "C"; expected "B[Any]"
     self.x = bc
     self.f(bc)
 
@@ -394,7 +394,7 @@ B(1)
 C(1)
 C('a')  # E: Argument 1 to "C" has incompatible type "str"; expected "int"
 D(A(1))
-D(1)  # E: Argument 1 to "D" has incompatible type "int"; expected A[<nothing>]
+D(1)  # E: Argument 1 to "D" has incompatible type "int"; expected "A[<nothing>]"
 
 
 [case testInheritedConstructor2]
@@ -427,9 +427,9 @@ adc = None # type: A[D, C]
 ic = None # type: I[C]
 id = None # type: I[D]
 
-ic = acd # E: Incompatible types in assignment (expression has type A[C, D], variable has type I[C])
-id = adc # E: Incompatible types in assignment (expression has type A[D, C], variable has type I[D])
-adc = ic # E: Incompatible types in assignment (expression has type I[C], variable has type A[D, C])
+ic = acd # E: Incompatible types in assignment (expression has type "A[C, D]", variable has type "I[C]")
+id = adc # E: Incompatible types in assignment (expression has type "A[D, C]", variable has type "I[D]")
+adc = ic # E: Incompatible types in assignment (expression has type "I[C]", variable has type "A[D, C]")
 
 ic = adc
 id = acd
@@ -451,11 +451,11 @@ class I(Generic[S]): pass
 class B(I[C]): pass
 class A(B): pass
 
-ie = a # E: Incompatible types in assignment (expression has type "A", variable has type I[E])
-a = ic # E: Incompatible types in assignment (expression has type I[C], variable has type "A")
-a = id # E: Incompatible types in assignment (expression has type I[D], variable has type "A")
+ie = a # E: Incompatible types in assignment (expression has type "A", variable has type "I[E]")
+a = ic # E: Incompatible types in assignment (expression has type "I[C]", variable has type "A")
+a = id # E: Incompatible types in assignment (expression has type "I[D]", variable has type "A")
 a = b  # E: Incompatible types in assignment (expression has type "B", variable has type "A")
-id = a # E: Incompatible types in assignment (expression has type "A", variable has type I[D])
+id = a # E: Incompatible types in assignment (expression has type "A", variable has type "I[D]")
 
 ic = a
 b = a
@@ -486,8 +486,8 @@ a, i, j = None, None, None # type: (A[object], I[object], J[object])
 ii = a
 jj = a
 jj = i
-a = i # E: Incompatible types in assignment (expression has type I[object], variable has type A[object])
-a = j # E: Incompatible types in assignment (expression has type J[object], variable has type A[object])
+a = i # E: Incompatible types in assignment (expression has type "I[object]", variable has type "A[object]")
+a = j # E: Incompatible types in assignment (expression has type "J[object]", variable has type "A[object]")
 
 class J(Generic[t]): pass
 class X(metaclass=ABCMeta): pass
@@ -546,7 +546,7 @@ class A(B):
 class C: pass
 class D: pass
 [out]
-main:7: error: Incompatible types in assignment (expression has type "A", variable has type I[D])
+main:7: error: Incompatible types in assignment (expression has type "A", variable has type "I[D]")
 
 [case testSubclassingGenericABCWithDeepHierarchy2]
 from typing import Any, TypeVar, Generic
@@ -704,7 +704,7 @@ a = None  # type: G[A]
 b = None  # type: G[B]
 c = None  # type: G[C]
 
-b = a  # E: Incompatible types in assignment (expression has type G[A], variable has type G[B])
+b = a  # E: Incompatible types in assignment (expression has type "G[A]", variable has type "G[B]")
 b = c
 [builtins fixtures/bool.pyi]
 [out]
@@ -723,7 +723,7 @@ b = None  # type: G[B]
 c = None  # type: G[C]
 
 b = a
-b = c  # E: Incompatible types in assignment (expression has type G[C], variable has type G[B])
+b = c  # E: Incompatible types in assignment (expression has type "G[C]", variable has type "G[B]")
 [builtins fixtures/bool.pyi]
 [out]
 
@@ -740,8 +740,8 @@ a = None  # type: G[A]
 b = None  # type: G[B]
 c = None  # type: G[C]
 
-b = a  # E: Incompatible types in assignment (expression has type G[A], variable has type G[B])
-b = c  # E: Incompatible types in assignment (expression has type G[C], variable has type G[B])
+b = a  # E: Incompatible types in assignment (expression has type "G[A]", variable has type "G[B]")
+b = c  # E: Incompatible types in assignment (expression has type "G[C]", variable has type "G[B]")
 [builtins fixtures/bool.pyi]
 [out]
 
diff --git a/test-data/unit/check-generics.test b/test-data/unit/check-generics.test
--- a/test-data/unit/check-generics.test
+++ b/test-data/unit/check-generics.test
@@ -79,8 +79,8 @@ class A(Generic[T]): pass
 class B: pass
 class C(B): pass
 [out]
-main:4: error: Incompatible types in assignment (expression has type A[B], variable has type A[C])
-main:5: error: Incompatible types in assignment (expression has type A[C], variable has type A[B])
+main:4: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
+main:5: error: Incompatible types in assignment (expression has type "A[C]", variable has type "A[B]")
 
 [case testGenericTypeCompatibilityWithAny]
 from typing import Any, TypeVar, Generic
@@ -115,8 +115,8 @@ class A(Generic[T]):
 class B: pass
 class C: pass
 [out]
-main:7: error: Incompatible types in assignment (expression has type A[C], variable has type A[B])
-main:8: error: Incompatible types in assignment (expression has type A[B], variable has type A[C])
+main:7: error: Incompatible types in assignment (expression has type "A[C]", variable has type "A[B]")
+main:8: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
 
 [case testMultipleGenericTypeParametersWithMemberVars]
 from typing import TypeVar, Generic
@@ -183,9 +183,9 @@ class A(Generic[S, T]):
 class B: pass
 class C(B):pass
 [out]
-main:8: error: Incompatible types in assignment (expression has type A[B, C], variable has type A[B, B])
-main:9: error: Incompatible types in assignment (expression has type A[C, B], variable has type A[B, B])
-main:10: error: Incompatible types in assignment (expression has type A[B, B], variable has type A[B, C])
+main:8: error: Incompatible types in assignment (expression has type "A[B, C]", variable has type "A[B, B]")
+main:9: error: Incompatible types in assignment (expression has type "A[C, B]", variable has type "A[B, B]")
+main:10: error: Incompatible types in assignment (expression has type "A[B, B]", variable has type "A[B, C]")
 
 
 -- Simple generic type bodies
@@ -208,7 +208,7 @@ x = None # type: B
 class B: pass
 [out]
 main:7: error: Argument 1 to "f" of "A" has incompatible type "B"; expected "T"
-main:8: error: Incompatible types in assignment (expression has type A[T], variable has type A[B])
+main:8: error: Incompatible types in assignment (expression has type "A[T]", variable has type "A[B]")
 
 [case testGenericTypeBodyWithMultipleVariables]
 from typing import TypeVar, Generic
@@ -229,8 +229,8 @@ class B: pass
 [out]
 main:8: error: Incompatible types in assignment (expression has type "T", variable has type "S")
 main:9: error: Incompatible types in assignment (expression has type "S", variable has type "T")
-main:10: error: Incompatible types in assignment (expression has type A[S, T], variable has type A[S, B])
-main:11: error: Incompatible types in assignment (expression has type A[S, T], variable has type A[T, T])
+main:10: error: Incompatible types in assignment (expression has type "A[S, T]", variable has type "A[S, B]")
+main:11: error: Incompatible types in assignment (expression has type "A[S, T]", variable has type "A[T, T]")
 
 [case testCompatibilityOfNoneWithTypeVar]
 from typing import TypeVar, Generic
@@ -284,9 +284,9 @@ class B: pass
 class C: pass
 [out]
 main:8: error: Incompatible types in assignment (expression has type "C", variable has type "B")
-main:9: error: Unsupported operand types for + (A[B, C] and "C")
+main:9: error: Unsupported operand types for + ("A[B, C]" and "C")
 main:10: error: Incompatible types in assignment (expression has type "B", variable has type "C")
-main:11: error: Invalid index type "B" for A[B, C]; expected type "C"
+main:11: error: Invalid index type "B" for "A[B, C]"; expected type "C"
 
 [case testOperatorAssignmentWithIndexLvalue1]
 from typing import TypeVar, Generic
@@ -309,7 +309,7 @@ class C:
     def __add__(self, o: 'C') -> 'C': pass
 [out]
 main:7: error: Unsupported operand types for + ("C" and "B")
-main:8: error: Invalid index type "C" for A[C]; expected type "B"
+main:8: error: Invalid index type "C" for "A[C]"; expected type "B"
 
 [case testOperatorAssignmentWithIndexLvalue2]
 from typing import TypeVar, Generic
@@ -330,9 +330,9 @@ class B: pass
 class C:
     def __add__(self, o: 'C') -> 'C': pass
 [out]
-main:7: error: Invalid index type "B" for A[C]; expected type "C"
-main:8: error: Invalid index type "C" for A[C]; expected type "B"
-main:9: error: Invalid index type "B" for A[C]; expected type "C"
+main:7: error: Invalid index type "B" for "A[C]"; expected type "C"
+main:8: error: Invalid index type "C" for "A[C]"; expected type "B"
+main:9: error: Invalid index type "B" for "A[C]"; expected type "C"
 
 
 -- Nested generic types
@@ -364,8 +364,8 @@ class B:
 class C:
     pass
 [out]
-main:8: error: Incompatible types in assignment (expression has type A[B], variable has type A[C])
-main:9: error: Incompatible types in assignment (expression has type A[A[B]], variable has type A[A[C]])
+main:8: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
+main:9: error: Incompatible types in assignment (expression has type "A[A[B]]", variable has type "A[A[C]]")
 
 
 -- Generic functions
@@ -384,7 +384,7 @@ def f(s: S, t: T) -> p[T, A]:
     s = t           # E: Incompatible types in assignment (expression has type "T", variable has type "S")
     p_s_a = None  # type: p[S, A]
     if s:
-        return p_s_a # E: Incompatible return value type (got p[S, A], expected p[T, A])
+        return p_s_a # E: Incompatible return value type (got "p[S, A]", expected "p[T, A]")
     b = t # type: T
     c = s # type: S
     p_t_a = None  # type: p[T, A]
@@ -402,10 +402,10 @@ class A(Generic[T]):
         s = t # E: Incompatible types in assignment (expression has type "T", variable has type "S")
         p_s_s = None  # type: p[S, S]
         if s:
-            return p_s_s # E: Incompatible return value type (got p[S, S], expected p[S, T])
+            return p_s_s # E: Incompatible return value type (got "p[S, S]", expected "p[S, T]")
         p_t_t = None  # type: p[T, T]
         if t:
-            return p_t_t # E: Incompatible return value type (got p[T, T], expected p[S, T])
+            return p_t_t # E: Incompatible return value type (got "p[T, T]", expected "p[S, T]")
         t = t
         s = s
         p_s_t = None  # type: p[S, T]
@@ -448,7 +448,7 @@ A[int, str, int]() # E: Type application has too many types (2 expected)
 a = None # type: A
 class A: pass
 a[A]()  # E: Value of type "A" is not indexable
-A[A]()  # E: The type Type[A] is not generic and not indexable
+A[A]()  # E: The type "Type[A]" is not generic and not indexable
 [out]
 
 [case testTypeApplicationArgTypes]
@@ -504,7 +504,7 @@ Alias[int]("a")  # E: Argument 1 to "Node" has incompatible type "str"; expected
 [out]
 
 [case testTypeApplicationCrash]
-type[int] # this was crashing, see #2302 (comment)  # E: The type Type[type] is not generic and not indexable
+type[int] # this was crashing, see #2302 (comment)  # E: The type "Type[type]" is not generic and not indexable
 [out]
 
 
@@ -564,7 +564,7 @@ def func(x: IntNode[T]) -> IntNode[T]:
     return x
 reveal_type(func) # E: Revealed type is 'def [T] (x: __main__.Node[builtins.int, T`-1]) -> __main__.Node[builtins.int, T`-1]'
 
-func(1) # E: Argument 1 to "func" has incompatible type "int"; expected Node[int, <nothing>]
+func(1) # E: Argument 1 to "func" has incompatible type "int"; expected "Node[int, <nothing>]"
 func(Node('x', 1)) # E: Argument 1 to "Node" has incompatible type "str"; expected "int"
 reveal_type(func(Node(1, 'x'))) # E: Revealed type is '__main__.Node[builtins.int, builtins.str*]'
 
@@ -693,7 +693,7 @@ l.meth().append(1)
 reveal_type(l.meth()) # E: Revealed type is 'builtins.list*[builtins.int]'
 l.meth().append('x') # E: Argument 1 to "append" of "list" has incompatible type "str"; expected "int"
 
-ListedNode[str]([]).x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type List[str])
+ListedNode[str]([]).x = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "List[str]")
 
 [builtins fixtures/list.pyi]
 
@@ -715,7 +715,7 @@ def f_bad(x: T) -> D[T]:
     return D(1)  # Error, see out
 
 L[int]().append(Node((1, 1)))
-L[int]().append(5) # E: Argument 1 to "append" of "list" has incompatible type "int"; expected Node[Tuple[int, int]]
+L[int]().append(5) # E: Argument 1 to "append" of "list" has incompatible type "int"; expected "Node[Tuple[int, int]]"
 
 x = D((1, 1)) # type: D[int]
 y = D(5) # type: D[int] # E: Argument 1 to "D" has incompatible type "int"; expected "Tuple[int, int]"
@@ -779,7 +779,7 @@ if not isinstance(s, str):
 
 z = None # type: TNode # Same as TNode[Any]
 z.x
-z.foo() # E: Item Node[int] of "Union[Any, Node[int]]" has no attribute "foo"
+z.foo() # E: Item "Node[int]" of "Union[Any, Node[int]]" has no attribute "foo"
 
 [builtins fixtures/isinstance.pyi]
 
@@ -825,9 +825,9 @@ reveal_type(make_cb(1)) # E: Revealed type is 'def (*Any, **Any) -> builtins.int
 def use_cb(arg: T, cb: C2[T]) -> Node[T]:
     return cb(arg, arg)
 
-use_cb(1, 1) # E: Argument 2 to "use_cb" has incompatible type "int"; expected Callable[[int, int], Node[int]]
+use_cb(1, 1) # E: Argument 2 to "use_cb" has incompatible type "int"; expected "Callable[[int, int], Node[int]]"
 my_cb = None # type: C2[int]
-use_cb('x', my_cb) # E: Argument 2 to "use_cb" has incompatible type Callable[[int, int], Node[int]]; expected Callable[[str, str], Node[str]]
+use_cb('x', my_cb) # E: Argument 2 to "use_cb" has incompatible type "Callable[[int, int], Node[int]]"; expected "Callable[[str, str], Node[str]]"
 reveal_type(use_cb(1, my_cb)) # E: Revealed type is '__main__.Node[builtins.int]'
 
 [out]
@@ -848,7 +848,7 @@ def fun2(v: Vec[T], scale: T) -> Vec[T]:
     return v
 
 reveal_type(fun1([(1, 1)])) # E: Revealed type is 'builtins.int*'
-fun1(1) # E: Argument 1 to "fun1" has incompatible type "int"; expected List[Tuple[int, int]]
+fun1(1) # E: Argument 1 to "fun1" has incompatible type "int"; expected "List[Tuple[int, int]]"
 fun1([(1, 'x')]) # E: Cannot infer type argument 1 of "fun1"
 
 reveal_type(fun2([(1, 1)], 1)) # E: Revealed type is 'builtins.list[Tuple[builtins.int*, builtins.int*]]'
@@ -869,7 +869,7 @@ n.y = 'x' # E: Incompatible types in assignment (expression has type "str", vari
 def f(x: Node[T, T]) -> TupledNode[T]:
     return Node(x.x, (x.x, x.x))
 
-f(1) # E: Argument 1 to "f" has incompatible type "int"; expected Node[<nothing>, <nothing>]
+f(1) # E: Argument 1 to "f" has incompatible type "int"; expected "Node[<nothing>, <nothing>]"
 f(Node(1, 'x')) # E: Cannot infer type argument 1 of "f"
 reveal_type(Node('x', 'x')) # E: Revealed type is 'a.Node[builtins.str*, builtins.str*]'
 
@@ -978,7 +978,7 @@ class C:
     c: Type[object] = Iterable[int]  # This is however also a variable
     a = B
     b = int  # E: Cannot assign multiple types to name "b" without an explicit "Type[...]" annotation \
-             # E: Incompatible types in assignment (expression has type Type[int], variable has type "Type alias to Union")
+             # E: Incompatible types in assignment (expression has type "Type[int]", variable has type "Type alias to Union")
     c = int
     def f(self, x: a) -> None: pass  # E: Invalid type "__main__.C.a"
     def g(self, x: b) -> None: pass
@@ -1343,7 +1343,7 @@ Z = TypeVar('Z')
 class OO: pass
 a = None # type: A[object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object, object]
 
-f(a) # E: Argument 1 to "f" has incompatible type A[...]; expected "OO"
+f(a) # E: Argument 1 to "f" has incompatible type "A[...]"; expected "OO"
 
 def f(a: OO) -> None:
     pass
@@ -1354,7 +1354,7 @@ from typing import TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
 a = None # type: A[object, B]
-f(a) # E: Argument 1 to "f" has incompatible type A[object, B]; expected "B"
+f(a) # E: Argument 1 to "f" has incompatible type "A[object, B]"; expected "B"
 
 def f(a: 'B') -> None: pass
 class A(Generic[S, T]): pass
@@ -1365,7 +1365,7 @@ from typing import Callable, TypeVar, Generic
 S = TypeVar('S')
 T = TypeVar('T')
 a = None # type: A[object, Callable[[], None]]
-f(a) # E: Argument 1 to "f" has incompatible type A[object, Callable[[], None]]; expected "B"
+f(a) # E: Argument 1 to "f" has incompatible type "A[object, Callable[[], None]]"; expected "B"
 
 def f(a: 'B') -> None: pass
 class A(Generic[S, T]): pass
@@ -1499,25 +1499,25 @@ y1 = f1
 y1 = f1
 y1 = f2
 y1 = f3
-y1 = f4 # E: Incompatible types in assignment (expression has type Callable[[int], A], variable has type Callable[[A], A])
+y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A]", variable has type "Callable[[A], A]")
 
 y2 = f2
 y2 = f2
-y2 = f1 # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[A], B])
-y2 = f3 # E: Incompatible types in assignment (expression has type Callable[[B], B], variable has type Callable[[A], B])
-y2 = f4 # E: Incompatible types in assignment (expression has type Callable[[int], A], variable has type Callable[[A], B])
+y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], B]")
+y2 = f3 # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[A], B]")
+y2 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A]", variable has type "Callable[[A], B]")
 
 y3 = f3
 y3 = f3
 y3 = f1
 y3 = f2
-y3 = f4 # E: Incompatible types in assignment (expression has type Callable[[int], A], variable has type Callable[[B], B])
+y3 = f4 # E: Incompatible types in assignment (expression has type "Callable[[int], A]", variable has type "Callable[[B], B]")
 
 y4 = f4
 y4 = f4
-y4 = f1 # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[int], A])
+y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[int], A]")
 y4 = f2
-y4 = f3 # E: Incompatible types in assignment (expression has type Callable[[B], B], variable has type Callable[[int], A])
+y4 = f3 # E: Incompatible types in assignment (expression has type "Callable[[B], B]", variable has type "Callable[[int], A]")
 
 [case testSubtypingWithGenericInnerFunctions]
 from typing import TypeVar
@@ -1533,24 +1533,24 @@ def outer(t: T) -> None:
 
     y1 = f1
     y1 = f2
-    y1 = f3 # E: Incompatible types in assignment (expression has type Callable[[T], A], variable has type Callable[[A], A])
-    y1 = f4 # E: Incompatible types in assignment (expression has type Callable[[A], T], variable has type Callable[[A], A])
-    y1 = f5 # E: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[A], A])
+    y1 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A]", variable has type "Callable[[A], A]")
+    y1 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A], T]", variable has type "Callable[[A], A]")
+    y1 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[A], A]")
 
     y2 = f2
-    y2 = f1 # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[A], B])
+    y2 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], B]")
 
     y3 = f3
-    y3 = f1 # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[T], A])
+    y3 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[T], A]")
     y3 = f2
-    y3 = f4 # E: Incompatible types in assignment (expression has type Callable[[A], T], variable has type Callable[[T], A])
-    y3 = f5 # E: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[T], A])
+    y3 = f4 # E: Incompatible types in assignment (expression has type "Callable[[A], T]", variable has type "Callable[[T], A]")
+    y3 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[T], A]")
 
     y4 = f4
-    y4 = f1 # E: Incompatible types in assignment (expression has type Callable[[A], A], variable has type Callable[[A], T])
+    y4 = f1 # E: Incompatible types in assignment (expression has type "Callable[[A], A]", variable has type "Callable[[A], T]")
     y4 = f2
-    y4 = f3 # E: Incompatible types in assignment (expression has type Callable[[T], A], variable has type Callable[[A], T])
-    y4 = f5 # E: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[A], T])
+    y4 = f3 # E: Incompatible types in assignment (expression has type "Callable[[T], A]", variable has type "Callable[[A], T]")
+    y4 = f5 # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[A], T]")
 
     y5 = f5
     y5 = f1
@@ -1568,8 +1568,8 @@ g1(f)
 def g2(f: Callable[[int], int]) -> None: pass
 g2(f)
 def g3(f: Callable[[object], object]) -> None: pass
-g3(f) # E: Argument 1 to "g3" has incompatible type Callable[[T], T]; \
-           expected Callable[[object], object]
+g3(f) # E: Argument 1 to "g3" has incompatible type "Callable[[T], T]"; \
+           expected "Callable[[object], object]"
 
 [case testSubtypingWithGenericFunctionUsingTypevarWithValues2-skip]
 from typing import TypeVar, Callable
@@ -1626,7 +1626,7 @@ T = TypeVar('T')
 class C(Generic[T]):
     def __init__(self) -> None: pass
 x = C # type: Callable[[], C[int]]
-y = C # type: Callable[[], int] # E: Incompatible types in assignment (expression has type Type[C[Any]], variable has type Callable[[], int])
+y = C # type: Callable[[], int] # E: Incompatible types in assignment (expression has type "Type[C[Any]]", variable has type "Callable[[], int]")
 
 
 -- Special cases
diff --git a/test-data/unit/check-ignore.test b/test-data/unit/check-ignore.test
--- a/test-data/unit/check-ignore.test
+++ b/test-data/unit/check-ignore.test
@@ -194,7 +194,7 @@ foo(Child())
 def bar(x: Base[str, str]) -> None: pass
 bar(Child())
 [out]
-main:19: error: Argument 1 to "bar" has incompatible type "Child"; expected Base[str, str]
+main:19: error: Argument 1 to "bar" has incompatible type "Child"; expected "Base[str, str]"
 
 [case testTypeIgnoreLineNumberWithinFile]
 import m
diff --git a/test-data/unit/check-inference-context.test b/test-data/unit/check-inference-context.test
--- a/test-data/unit/check-inference-context.test
+++ b/test-data/unit/check-inference-context.test
@@ -13,7 +13,7 @@ b = None # type: B
 
 ao = f()
 ab = f()
-b = f() # E: Incompatible types in assignment (expression has type A[<nothing>], variable has type "B")
+b = f() # E: Incompatible types in assignment (expression has type "A[<nothing>]", variable has type "B")
 
 def f() -> 'A[T]': pass
 
@@ -29,7 +29,7 @@ b = None # type: B
 
 ao = A()
 ab = A()
-b = A() # E: Incompatible types in assignment (expression has type A[<nothing>], variable has type "B")
+b = A() # E: Incompatible types in assignment (expression has type "A[<nothing>]", variable has type "B")
 
 class A(Generic[T]): pass
 class B: pass
@@ -74,10 +74,10 @@ def g() -> None:
     b = None # type: B
 
     x = f(o)
-    ab = x # E: Incompatible types in assignment (expression has type A[object], variable has type A[B])
+    ab = x # E: Incompatible types in assignment (expression has type "A[object]", variable has type "A[B]")
     ao = x
     y = f(b)
-    ao = y # E: Incompatible types in assignment (expression has type A[B], variable has type A[object])
+    ao = y # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
     ab = y
 
 def f(a: T) -> 'A[T]': pass
@@ -104,8 +104,8 @@ def g() -> None:
     ab = None # type: A[B]
     b = None # type: B
     x, y = f(b), f(b)
-    ao = x # E: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-    ao = y # E: Incompatible types in assignment (expression has type A[B], variable has type A[object])
+    ao = x # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+    ao = y # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
     ab = x
     ab = y
 
@@ -122,8 +122,8 @@ def h() -> None:
     ab = None # type: A[B]
     b = None # type: B
     x, y = g(f(b))
-    ao = x # E: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-    ao = y # E: Incompatible types in assignment (expression has type A[B], variable has type A[object])
+    ao = x # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+    ao = y # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
     ab = x
     ab = y
 
@@ -161,8 +161,8 @@ class A(Generic[T]): pass
 class B: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:8: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-main:9: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
+main:8: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+main:9: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
 
 [case testInferenceWithTypeVariableTwiceInReturnTypeAndMultipleVariables]
 from typing import TypeVar, Tuple, Generic
@@ -190,10 +190,10 @@ class A(Generic[T]): pass
 class B: pass
 [builtins fixtures/tuple.pyi]
 [out]
-main:9: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-main:10: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-main:11: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
-main:12: error: Incompatible types in assignment (expression has type A[B], variable has type A[object])
+main:9: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+main:10: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+main:11: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
+main:12: error: Incompatible types in assignment (expression has type "A[B]", variable has type "A[object]")
 
 
 -- Multiple tvar instances in arguments
@@ -309,7 +309,7 @@ ab = None # type: A[B]
 ac = None # type: A[C]
 
 ab.g(f(o))        # E: Argument 1 to "f" has incompatible type "object"; expected "B"
-ac = f(b).g(f(c)) # E: Incompatible types in assignment (expression has type A[B], variable has type A[C])
+ac = f(b).g(f(c)) # E: Incompatible types in assignment (expression has type "A[B]", variable has type "A[C]")
 ac = f(c).g(f(b)) # E: Argument 1 to "f" has incompatible type "B"; expected "C"
 
 ab = f(b).g(f(c))
@@ -334,7 +334,7 @@ aa = None # type: List[A]
 ao = None # type: List[object]
 a = None # type: A
 
-a = [] # E: Incompatible types in assignment (expression has type List[<nothing>], variable has type "A")
+a = [] # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "A")
 
 aa = []
 ao = []
@@ -401,7 +401,7 @@ ab = None # type: List[B]
 b = None # type: B
 o = None # type: object
 
-aao = [[o], ab] # E: List item 1 has incompatible type List[B]; expected List[object]
+aao = [[o], ab] # E: List item 1 has incompatible type "List[B]"; expected "List[object]"
 aab = [[], [o]] # E: List item 0 has incompatible type "object"; expected "B"
 
 aao = [[None], [b], [], [o]]
@@ -462,7 +462,7 @@ d = {A() : a_c,
 [case testInitializationWithInferredGenericType]
 from typing import TypeVar, Generic
 T = TypeVar('T')
-c = f(A()) # type: C[A] # E: Argument 1 to "f" has incompatible type "A"; expected C[A]
+c = f(A()) # type: C[A] # E: Argument 1 to "f" has incompatible type "A"; expected "C[A]"
 
 def f(x: T) -> T: pass
 class C(Generic[T]): pass
@@ -503,7 +503,7 @@ from abc import abstractmethod, ABCMeta
 t = TypeVar('t')
 x = A() # 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])
+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
@@ -610,9 +610,9 @@ f = lambda x: A() # type: Callable[[], A]
 f2 = lambda: A() # type: Callable[[A], A]
 class A: pass
 [out]
-main:2: error: Incompatible types in assignment (expression has type Callable[[Any], A], variable has type Callable[[], A])
+main:2: error: Incompatible types in assignment (expression has type "Callable[[Any], A]", variable has type "Callable[[], A]")
 main:2: error: Cannot infer type of lambda
-main:3: error: Incompatible types in assignment (expression has type Callable[[], A], variable has type Callable[[A], A])
+main:3: error: Incompatible types in assignment (expression has type "Callable[[], A]", variable has type "Callable[[A], A]")
 main:3: error: Cannot infer type of lambda
 
 [case testEllipsisContextForLambda]
@@ -624,7 +624,7 @@ f4 = lambda x: x # type: Callable[..., int]
 g = lambda x: 1 # type: Callable[..., str]
 [builtins fixtures/dict.pyi]
 [out]
-main:6: error: Incompatible types in assignment (expression has type Callable[[Any], int], variable has type Callable[..., str])
+main:6: error: Incompatible types in assignment (expression has type "Callable[[Any], int]", variable has type "Callable[..., str]")
 main:6: error: Incompatible return value type (got "int", expected "str")
 
 [case testEllipsisContextForLambda2]
@@ -651,7 +651,7 @@ def f(func: Callable[[T], S], *z: T, r: S = None) -> S: pass
 f(lambda x: 0 if isinstance(x, B) else 1) # E: Cannot infer type argument 1 of "f"
 f(lambda x: 0 if isinstance(x, B) else 1, A())() # E: "int" not callable
 f(lambda x: x if isinstance(x, B) else B(), A(), r=B())() # E: "B" not callable
-f( # E: Argument 1 to "f" has incompatible type Callable[[A], A]; expected Callable[[A], B]
+f( # E: Argument 1 to "f" has incompatible type "Callable[[A], A]"; expected "Callable[[A], B]"
     lambda x: B() if isinstance(x, B) else x, # E: Incompatible return value type (got "A", expected "B")
     A(), r=B())
 [builtins fixtures/isinstance.pyi]
@@ -679,7 +679,7 @@ class B: pass
 
 m = map(g, [A()])
 b = m # type: List[B]
-a = m # type: List[A] # E: Incompatible types in assignment (expression has type List[B], variable has type List[A])
+a = m # type: List[A] # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]")
 [builtins fixtures/list.pyi]
 
 
@@ -693,8 +693,8 @@ a, b, c = None, None, None # type: (List[A], List[B], List[C])
 a = a or []
 a = [] or a
 b = b or [C()]
-a = a or b # E: Incompatible types in assignment (expression has type "Union[List[A], List[B]]", variable has type List[A])
-b = b or c # E: Incompatible types in assignment (expression has type "Union[List[B], List[C]]", variable has type List[B])
+a = a or b # E: Incompatible types in assignment (expression has type "Union[List[A], List[B]]", variable has type "List[A]")
+b = b or c # E: Incompatible types in assignment (expression has type "Union[List[B], List[C]]", variable has type "List[B]")
 
 class A: pass
 class B: pass
@@ -748,7 +748,7 @@ from typing import List
 i = None # type: List[int]
 s = None # type: List[str]
 i = i = []
-i = s = [] # E: Incompatible types in assignment (expression has type List[str], variable has type List[int])
+i = s = [] # E: Incompatible types in assignment (expression has type "List[str]", variable has type "List[int]")
 [builtins fixtures/list.pyi]
 
 [case testContextForAttributeDeclaredInInit]
@@ -825,7 +825,7 @@ S = TypeVar('S')
 def f(a: T, b: S) -> None:
     c = lambda x: x  # type: Callable[[T], S]
 [out]
-main:5: error: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[T], S])
+main:5: error: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[T], S]")
 main:5: error: Incompatible return value type (got "T", expected "S")
 
 [case testLambdaInGenericClass]
@@ -836,7 +836,7 @@ class A(Generic[T]):
     def f(self, b: S) -> None:
         c = lambda x: x  # type: Callable[[T], S]
 [out]
-main:6: error: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[T], S])
+main:6: error: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[T], S]")
 main:6: error: Incompatible return value type (got "T", expected "S")
 
 [case testRevealTypeContext]
diff --git a/test-data/unit/check-inference.test b/test-data/unit/check-inference.test
--- a/test-data/unit/check-inference.test
+++ b/test-data/unit/check-inference.test
@@ -69,7 +69,7 @@ class B: pass
 import typing
 def f() -> None:
     a = g()
-    None(a) # E: None not callable
+    None(a) # E: "None" not callable
     a.x()
 
 def g(): pass
@@ -81,7 +81,7 @@ g = None # type: Any
 
 def f(a: Any) -> None:
     b = g
-    None(b) # E: None not callable
+    None(b) # E: "None" not callable
     a.x()
 [out]
 
@@ -126,7 +126,7 @@ a_s = None # type: A[str]
 def f() -> None:
     a_int = A() # type: A[int]
     a = a_int
-    a = a_s # E: Incompatible types in assignment (expression has type A[str], variable has type A[int])
+    a = a_s # E: Incompatible types in assignment (expression has type "A[str]", variable has type "A[int]")
     a = a_i
 [builtins fixtures/tuple.pyi]
 [out]
@@ -480,11 +480,11 @@ ao = None # type: A[object]
 ab = None # type: A[B]
 ac = None # type: A[C]
 
-ab = f(ao) # E: Argument 1 to "f" has incompatible type A[object]; expected A[B]
-ao = f(ab) # E: Argument 1 to "f" has incompatible type A[B]; expected A[object]
-ab = f(ac) # E: Argument 1 to "f" has incompatible type A[C]; expected A[B]
-ab = g(ao) # E: Argument 1 to "g" has incompatible type A[object]; expected A[B]
-ao = g(ab) # E: Argument 1 to "g" has incompatible type A[B]; expected A[object]
+ab = f(ao) # E: Argument 1 to "f" has incompatible type "A[object]"; expected "A[B]"
+ao = f(ab) # E: Argument 1 to "f" has incompatible type "A[B]"; expected "A[object]"
+ab = f(ac) # E: Argument 1 to "f" has incompatible type "A[C]"; expected "A[B]"
+ab = g(ao) # E: Argument 1 to "g" has incompatible type "A[object]"; expected "A[B]"
+ao = g(ab) # E: Argument 1 to "g" has incompatible type "A[B]"; expected "A[object]"
 
 ab = f(ab)
 ac = f(ac)
@@ -648,7 +648,7 @@ def mymap(f: Callable[[t], s], a: List[t]) -> List[s]: pass
 l = mymap(f, [b])
 l = [A()]
 lb = [b]
-l = lb # E: Incompatible types in assignment (expression has type List[bool], variable has type List[A])
+l = lb # E: Incompatible types in assignment (expression has type "List[bool]", variable has type "List[A]")
 [builtins fixtures/for.pyi]
 
 [case testGenericFunctionWithTypeTypeAsCallable]
@@ -676,7 +676,7 @@ f(1, 1)() # E: "int" not callable
 
 def g(x: Union[T, List[T]]) -> List[T]: pass
 def h(x: List[str]) -> None: pass
-g('a')() # E: List[str] not callable
+g('a')() # E: "List[str]" not callable
 
 # The next line is a case where there are multiple ways to satisfy a constraint
 # involving a Union. Either T = List[str] or T = str would turn out to be valid,
@@ -684,7 +684,7 @@ g('a')() # E: List[str] not callable
 # to backtrack later) and defaults to T = <nothing>. The result is an
 # awkward error message. Either a better error message, or simply accepting the
 # call, would be preferable here.
-g(['a']) # E: Argument 1 to "g" has incompatible type List[str]; expected List[<nothing>]
+g(['a']) # E: Argument 1 to "g" has incompatible type "List[str]"; expected "List[<nothing>]"
 
 h(g(['a']))
 
@@ -693,7 +693,7 @@ a = [1]
 b = ['b']
 i(a, a, b)
 i(b, a, b)
-i(a, b, b) # E: Argument 1 to "i" has incompatible type List[int]; expected List[str]
+i(a, b, b) # E: Argument 1 to "i" has incompatible type "List[int]"; expected "List[str]"
 [builtins fixtures/list.pyi]
 
 [case testCallableListJoinInference]
@@ -778,7 +778,7 @@ from typing import TypeVar, Union, List
 T = TypeVar('T')
 def f() -> List[T]: pass
 d1 = f() # type: Union[List[int], str]
-d2 = f() # type: Union[int, str] # E: Incompatible types in assignment (expression has type List[<nothing>], variable has type "Union[int, str]")
+d2 = f() # type: Union[int, str] # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "Union[int, str]")
 def g(x: T) -> List[T]: pass
 d3 = g(1) # type: Union[List[int], List[str]]
 [builtins fixtures/list.pyi]
@@ -792,7 +792,7 @@ def k1(x: int, y: List[T]) -> List[Union[T, int]]: pass
 def k2(x: S, y: List[T]) -> List[Union[T, int]]: pass
 a = k2
 a = k2
-a = k1 # E: Incompatible types in assignment (expression has type Callable[[int, List[T]], List[Union[T, int]]], variable has type Callable[[S, List[T]], List[Union[T, int]]])
+a = k1 # E: Incompatible types in assignment (expression has type "Callable[[int, List[T]], List[Union[T, int]]]", variable has type "Callable[[S, List[T]], List[Union[T, int]]]")
 b = k1
 b = k1
 b = k2
@@ -840,7 +840,7 @@ def d_aa() -> Dict[A, A]: return {}
 a, b = None, None # type: (A, B)
 d = {a:b}
 d = d_ab()
-d = d_aa() # E: Incompatible types in assignment (expression has type Dict[A, A], variable has type Dict[A, B])
+d = d_aa() # E: Incompatible types in assignment (expression has type "Dict[A, A]", variable has type "Dict[A, B]")
 [builtins fixtures/dict.pyi]
 
 [case testSetLiteral]
@@ -851,7 +851,7 @@ def s_s() -> Set[str]: return set()
 s = {a}
 s = {x}
 s = s_i()
-s = s_s() # E: Incompatible types in assignment (expression has type Set[str], variable has type Set[int])
+s = s_s() # E: Incompatible types in assignment (expression has type "Set[str]", variable has type "Set[int]")
 [builtins fixtures/set.pyi]
 
 [case testSetWithStarExpr]
@@ -1074,14 +1074,14 @@ from typing import List, Callable
 li = [1]
 l = lambda: li
 f1 = l # type: Callable[[], List[int]]
-f2 = l # type: Callable[[], List[str]] # E: Incompatible types in assignment (expression has type Callable[[], List[int]], variable has type Callable[[], List[str]])
+f2 = l # type: Callable[[], List[str]] # E: Incompatible types in assignment (expression has type "Callable[[], List[int]]", variable has type "Callable[[], List[str]]")
 [builtins fixtures/list.pyi]
 
 [case testInferLambdaType2]
 from typing import List, Callable
 l = lambda: [B()]
 f1 = l # type: Callable[[], List[B]]
-f2 = l # type: Callable[[], List[A]] # E: Incompatible types in assignment (expression has type Callable[[], List[B]], variable has type Callable[[], List[A]])
+f2 = l # type: Callable[[], List[A]] # E: Incompatible types in assignment (expression has type "Callable[[], List[B]]", variable has type "Callable[[], List[A]]")
 
 class A: pass
 class B: pass
@@ -1119,7 +1119,7 @@ from typing import Callable
 def f(a: Callable[..., None] = lambda *a, **k: None):
     pass
 
-def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default for argument "a" (default has type Callable[[VarArg(Any), KwArg(Any)], int], argument has type Callable[..., None])
+def g(a: Callable[..., None] = lambda *a, **k: 1):  # E: Incompatible default for argument "a" (default has type "Callable[[VarArg(Any), KwArg(Any)], int]", argument has type "Callable[..., None]")
     pass
 [builtins fixtures/dict.pyi]
 
@@ -1154,7 +1154,7 @@ a = None # type: List[A]
 o = None # type: List[object]
 a2 = a or []
 a = a2
-a2 = o # E: Incompatible types in assignment (expression has type List[object], variable has type List[A])
+a2 = o # E: Incompatible types in assignment (expression has type "List[object]", variable has type "List[A]")
 class A: pass
 [builtins fixtures/list.pyi]
 
@@ -1194,7 +1194,7 @@ x2 = [B(), A()]
 x3 = [B(), B()]
 a = x1
 a = x2
-a = x3 # E: Incompatible types in assignment (expression has type List[B], variable has type List[A])
+a = x3 # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]")
 [builtins fixtures/list.pyi]
 
 [case testListWithDucktypeCompatibilityAndTransitivity]
@@ -1210,7 +1210,7 @@ x2 = [C(), A()]
 x3 = [B(), C()]
 a = x1
 a = x2
-a = x3 # E: Incompatible types in assignment (expression has type List[B], variable has type List[A])
+a = x3 # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]")
 [builtins fixtures/list.pyi]
 
 
@@ -1256,8 +1256,8 @@ a()
 a, b = [], []
 a.append(1)
 b.append('')
-a() # E: List[int] not callable
-b() # E: List[str] not callable
+a() # E: "List[int]" not callable
+b() # E: "List[str]" not callable
 [builtins fixtures/list.pyi]
 [out]
 
@@ -1371,14 +1371,14 @@ a.add('')  # E: Argument 1 to "add" of "set" has incompatible type "str"; expect
 [case testInferDictInitializedToEmpty]
 a = {}
 a[1] = ''
-a() # E: Dict[int, str] not callable
+a() # E: "Dict[int, str]" not callable
 [builtins fixtures/dict.pyi]
 [out]
 
 [case testInferDictInitializedToEmptyUsingUpdate]
 a = {}
 a.update({'': 42})
-a() # E: Dict[str, int] not callable
+a() # E: "Dict[str, int]" not callable
 [builtins fixtures/dict.pyi]
 [out]
 
@@ -1447,7 +1447,7 @@ def f() -> None:
 import typing
 def f() -> None:
     a = None
-    a.x() # E: None has no attribute "x"
+    a.x() # E: "None" has no attribute "x"
 [out]
 
 [case testGvarPartiallyInitializedToNone]
@@ -1504,7 +1504,7 @@ x = None
 def f() -> None:
     x = None
     x = 1
-x()  # E: None not callable
+x()  # E: "None" not callable
 
 [case testAttributePartiallyInitializedToNone]
 class A:
@@ -1523,8 +1523,8 @@ class A:
         self.x = 1
         self.x()
 [out]
-main:6: error: Incompatible types in assignment (expression has type "int", variable has type None)
-main:7: error: None not callable
+main:6: error: Incompatible types in assignment (expression has type "int", variable has type "None")
+main:7: error: "None" not callable
 
 [case testGlobalInitializedToNoneSetFromFunction]
 a = None
@@ -1553,7 +1553,7 @@ class A:
             pass
 [builtins fixtures/for.pyi]
 [out]
-main:5: error: None has no attribute "__iter__"
+main:5: error: "None" has no attribute "__iter__"
 
 [case testPartialTypeErrorSpecialCase2]
 # This used to crash.
@@ -1574,7 +1574,7 @@ class A:
             pass
 [builtins fixtures/for.pyi]
 [out]
-main:4: error: None has no attribute "__iter__"
+main:4: error: "None" has no attribute "__iter__"
 
 
 -- Multipass
@@ -1680,7 +1680,7 @@ def g(d: Dict[str, int]) -> None: pass
 def f() -> None:
     x = {}
     x[1] = y
-    g(x) # E: Argument 1 to "g" has incompatible type Dict[int, str]; expected Dict[str, int]
+    g(x) # E: Argument 1 to "g" has incompatible type "Dict[int, str]"; expected "Dict[str, int]"
     x[1] = 1 # E: Incompatible types in assignment (expression has type "int", target has type "str")
     x[1] = ''
 y = ''
@@ -1694,7 +1694,7 @@ def f() -> None:
     x = {}
     y
     x[1] = 1
-    g(x) # E: Argument 1 to "g" has incompatible type Dict[int, int]; expected Dict[str, int]
+    g(x) # E: Argument 1 to "g" has incompatible type "Dict[int, int]"; expected "Dict[str, int]"
 y = ''
 [builtins fixtures/dict.pyi]
 [out]
@@ -1713,7 +1713,7 @@ def f() -> None:
     y = o
     x = []
     x.append(y)
-    x() # E: List[int] not callable
+    x() # E: "List[int]" not callable
 o = 1
 [builtins fixtures/list.pyi]
 [out]
@@ -1723,7 +1723,7 @@ def f() -> None:
     y = o
     x = {}
     x[''] = y
-    x() # E: Dict[str, int] not callable
+    x() # E: "Dict[str, int]" not callable
 o = 1
 [builtins fixtures/dict.pyi]
 [out]
@@ -1825,20 +1825,20 @@ a2.foo2()
 [case testUnificationEmptyListLeft]
 def f(): pass
 a = [] if f() else [0]
-a() # E: List[int] not callable
+a() # E: "List[int]" not callable
 [builtins fixtures/list.pyi]
 
 [case testUnificationEmptyListRight]
 def f(): pass
 a = [0] if f() else []
-a() # E: List[int] not callable
+a() # E: "List[int]" not callable
 [builtins fixtures/list.pyi]
 
 [case testUnificationEmptyListLeftInContext]
 from typing import List
 def f(): pass
 a = [] if f() else [0] # type: List[int]
-a() # E: List[int] not callable
+a() # E: "List[int]" not callable
 [builtins fixtures/list.pyi]
 
 [case testUnificationEmptyListRightInContext]
@@ -1846,37 +1846,37 @@ a() # E: List[int] not callable
 from typing import List
 def f(): pass
 a = [0] if f() else [] # type: List[int]
-a() # E: List[int] not callable
+a() # E: "List[int]" not callable
 [builtins fixtures/list.pyi]
 
 [case testUnificationEmptySetLeft]
 def f(): pass
 a = set() if f() else {0}
-a() # E: Set[int] not callable
+a() # E: "Set[int]" not callable
 [builtins fixtures/set.pyi]
 
 [case testUnificationEmptyDictLeft]
 def f(): pass
 a = {} if f() else {0: 0}
-a() # E: Dict[int, int] not callable
+a() # E: "Dict[int, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testUnificationEmptyDictRight]
 def f(): pass
 a = {0: 0} if f() else {}
-a() # E: Dict[int, int] not callable
+a() # E: "Dict[int, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testUnificationDictWithEmptyListLeft]
 def f(): pass
 a = {0: []} if f() else {0: [0]}
-a() # E: Dict[int, List[int]] not callable
+a() # E: "Dict[int, List[int]]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testUnificationDictWithEmptyListRight]
 def f(): pass
 a = {0: [0]} if f() else {0: []}
-a() # E: Dict[int, List[int]] not callable
+a() # E: "Dict[int, List[int]]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testMisguidedSetItem]
diff --git a/test-data/unit/check-isinstance.test b/test-data/unit/check-isinstance.test
--- a/test-data/unit/check-isinstance.test
+++ b/test-data/unit/check-isinstance.test
@@ -684,7 +684,7 @@ while bool():
         x + 'a'
         break
     x + [1]
-    x + 'a'           # E: Unsupported operand types for + (List[int] and "str")
+    x + 'a'           # E: Unsupported operand types for + ("List[int]" and "str")
 x + [1]               # E: Unsupported operand types for + (likely involving Union)
 [builtins fixtures/isinstancelist.pyi]
 
@@ -1526,7 +1526,7 @@ def test_issubclass(cls: Type[Goblin]) -> None:
     else:
         reveal_type(cls)  # E: Revealed type is 'Type[__main__.Goblin]'
         cls.level
-        cls.job  # E: Type[Goblin] has no attribute "job"
+        cls.job  # E: "Type[Goblin]" has no attribute "job"
         g = cls()
         g.level = 15
         g.job  # E: "Goblin" has no attribute "job"
@@ -1547,7 +1547,7 @@ def test_issubclass(cls: Type[Mob]) -> None:
     if issubclass(cls, Goblin):
         reveal_type(cls)  # E: Revealed type is 'Type[__main__.Goblin]'
         cls.level
-        cls.job  # E: Type[Goblin] has no attribute "job"
+        cls.job  # E: "Type[Goblin]" has no attribute "job"
         g = cls()
         g.level = 15
         g.job  # E: "Goblin" has no attribute "job"
@@ -1561,8 +1561,8 @@ def test_issubclass(cls: Type[Mob]) -> None:
             g.job = 'Warrior' # E: Cannot assign to class variable "job" via instance
     else:
         reveal_type(cls)  # E: Revealed type is 'Type[__main__.Mob]'
-        cls.job  # E: Type[Mob] has no attribute "job"
-        cls.level  # E: Type[Mob] has no attribute "level"
+        cls.job  # E: "Type[Mob]" has no attribute "job"
+        cls.level  # E: "Type[Mob]" has no attribute "level"
         m = cls()
         m.level = 15  # E: "Mob" has no attribute "level"
         m.job  # E: "Mob" has no attribute "job"
@@ -1603,7 +1603,7 @@ def test_issubclass(cls: Type[Mob]) -> None:
     if issubclass(cls, (Goblin, GoblinAmbusher)):
         reveal_type(cls)  # E: Revealed type is 'Type[__main__.Goblin]'
         cls.level
-        cls.job  # E: Type[Goblin] has no attribute "job"
+        cls.job  # E: "Type[Goblin]" has no attribute "job"
         g = cls()
         g.level = 15
         g.job  # E: "Goblin" has no attribute "job"
@@ -1617,8 +1617,8 @@ def test_issubclass(cls: Type[Mob]) -> None:
             ga.job = "Warrior"  # E: Cannot assign to class variable "job" via instance
     else:
         reveal_type(cls)  # E: Revealed type is 'Type[__main__.Mob]'
-        cls.job  # E: Type[Mob] has no attribute "job"
-        cls.level  # E: Type[Mob] has no attribute "level"
+        cls.job  # E: "Type[Mob]" has no attribute "job"
+        cls.level  # E: "Type[Mob]" has no attribute "level"
         m = cls()
         m.level = 15  # E: "Mob" has no attribute "level"
         m.job  # E: "Mob" has no attribute "job"
diff --git a/test-data/unit/check-kwargs.test b/test-data/unit/check-kwargs.test
--- a/test-data/unit/check-kwargs.test
+++ b/test-data/unit/check-kwargs.test
@@ -4,7 +4,7 @@
 [case testTypeErrorInKeywordArgument]
 import typing
 def f(o: object) -> None: pass
-f(o=None()) # E: None not callable
+f(o=None()) # E: "None" not callable
 
 [case testSimpleKeywordArgument]
 import typing
@@ -89,8 +89,8 @@ class A: pass
 [case testKeywordArgumentsWithDynamicallyTypedCallable]
 from typing import Any
 f = None # type: Any
-f(x=f(), z=None()) # E: None not callable
-f(f, zz=None()) # E: None not callable
+f(x=f(), z=None()) # E: "None" not callable
+f(f, zz=None()) # E: "None" not callable
 f(x=None)
 
 [case testKeywordArgumentWithFunctionObject]
@@ -216,8 +216,8 @@ class A: pass
 from typing import Dict, Any
 def f( **kwargs: 'A') -> None:
     d1 = kwargs # type: Dict[str, A]
-    d2 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type Dict[str, A], variable has type Dict[A, Any])
-    d3 = kwargs # type: Dict[Any, str] # E: Incompatible types in assignment (expression has type Dict[str, A], variable has type Dict[Any, str])
+    d2 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type "Dict[str, A]", variable has type "Dict[A, Any]")
+    d3 = kwargs # type: Dict[Any, str] # E: Incompatible types in assignment (expression has type "Dict[str, A]", variable has type "Dict[Any, str]")
 class A: pass
 [builtins fixtures/dict.pyi]
 [out]
@@ -227,7 +227,7 @@ from typing import Dict, Any
 def f(**kwargs) -> None:
     d1 = kwargs # type: Dict[str, A]
     d2 = kwargs # type: Dict[str, str]
-    d3 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type Dict[str, Any], variable has type Dict[A, Any])
+    d3 = kwargs # type: Dict[A, Any] # E: Incompatible types in assignment (expression has type "Dict[str, Any]", variable has type "Dict[A, Any]")
 class A: pass
 [builtins fixtures/dict.pyi]
 [out]
@@ -252,8 +252,8 @@ d = None # type: Dict[str, A]
 f(**d)
 f(x=A(), **d)
 d2 = None # type: Dict[str, B]
-f(**d2)        # E: Argument 1 to "f" has incompatible type **Dict[str, B]; expected "A"
-f(x=A(), **d2) # E: Argument 2 to "f" has incompatible type **Dict[str, B]; expected "A"
+f(**d2)        # E: Argument 1 to "f" has incompatible type "**Dict[str, B]"; expected "A"
+f(x=A(), **d2) # E: Argument 2 to "f" has incompatible type "**Dict[str, B]"; expected "A"
 class A: pass
 class B: pass
 [builtins fixtures/dict.pyi]
@@ -316,7 +316,7 @@ def f(a: 'A', b: 'B') -> None: pass
 d = None # type: Dict[str, Any]
 f(**d)
 d2 = None # type: Dict[str, A]
-f(**d2) # E: Argument 1 to "f" has incompatible type **Dict[str, A]; expected "B"
+f(**d2) # E: Argument 1 to "f" has incompatible type "**Dict[str, A]"; expected "B"
 class A: pass
 class B: pass
 [builtins fixtures/dict.pyi]
@@ -362,15 +362,15 @@ def f(a: int) -> None:
     pass
 
 s = ('',)
-f(*s) # E: Argument 1 to "f" has incompatible type *"Tuple[str]"; expected "int"
+f(*s) # E: Argument 1 to "f" has incompatible type "*Tuple[str]"; expected "int"
 
 a = {'': 0}
-f(a) # E: Argument 1 to "f" has incompatible type Dict[str, int]; expected "int"
+f(a) # E: Argument 1 to "f" has incompatible type "Dict[str, int]"; expected "int"
 f(**a) # okay
 
 b = {'': ''}
-f(b) # E: Argument 1 to "f" has incompatible type Dict[str, str]; expected "int"
-f(**b) # E: Argument 1 to "f" has incompatible type **Dict[str, str]; expected "int"
+f(b) # E: Argument 1 to "f" has incompatible type "Dict[str, str]"; expected "int"
+f(**b) # E: Argument 1 to "f" has incompatible type "**Dict[str, str]"; expected "int"
 
 c = {0: 0}
 f(**c) # E: Keywords must be strings
diff --git a/test-data/unit/check-modules.test b/test-data/unit/check-modules.test
--- a/test-data/unit/check-modules.test
+++ b/test-data/unit/check-modules.test
@@ -201,7 +201,7 @@ None + ''
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckWithUnknownModule2]
 import m, nonexistent
@@ -213,7 +213,7 @@ x = 1
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testTypeCheckWithUnknownModule3]
@@ -226,7 +226,7 @@ x = 1
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 main:4: error: Incompatible types in assignment (expression has type "str", variable has type "int")
 
 [case testTypeCheckWithUnknownModule4]
@@ -236,7 +236,7 @@ None + ''
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
 main:1: error: Cannot find module named 'another'
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckWithUnknownModule5]
 import nonexistent as x
@@ -244,7 +244,7 @@ None + ''
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckWithUnknownModuleUsingFromImport]
 from nonexistent import x
@@ -252,7 +252,7 @@ None + ''
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckWithUnknownModuleUsingImportStar]
 from nonexistent import *
@@ -260,7 +260,7 @@ None + ''
 [out]
 main:1: error: Cannot find module named 'nonexistent'
 main:1: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports" flag would help)
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 [case testAccessingUnknownModule]
 import xyz
@@ -411,14 +411,14 @@ import typing
 __all__ = [1, 2, 3]
 [builtins fixtures/module_all.pyi]
 [out]
-main:2: error: Type of __all__ must be Sequence[str], not List[int]
+main:2: error: Type of __all__ must be "Sequence[str]", not "List[int]"
 
 [case testAllMustBeSequenceStr_python2]
 import typing
 __all__ = [1, 2, 3]
 [builtins_py2 fixtures/module_all_python2.pyi]
 [out]
-main:2: error: Type of __all__ must be Sequence[unicode], not List[int]
+main:2: error: Type of __all__ must be "Sequence[unicode]", not "List[int]"
 
 [case testAllUnicodeSequenceOK_python2]
 import typing
@@ -584,7 +584,7 @@ x = ''
 def f(x): pass
 def g(x): pass
 try:
-    from m import f, g # E: Incompatible import of "g" (imported name has type Callable[[Any, Any], Any], local name has type Callable[[Any], Any])
+    from m import f, g # E: Incompatible import of "g" (imported name has type "Callable[[Any, Any], Any]", local name has type "Callable[[Any], Any]")
 except:
     pass
 [file m.py]
@@ -620,7 +620,7 @@ def f(x): pass
 try:
     from m import f
 except:
-    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
 [file m.py]
 def f(): pass
 
@@ -630,7 +630,7 @@ from m import f
 def g() -> None:
     global f
     f = None
-    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+    f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
 [file m.py]
 def f(): pass
 [out]
@@ -638,7 +638,7 @@ def f(): pass
 [case testAssignToFuncDefViaNestedModules]
 import m.n
 m.n.f = None
-m.n.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+m.n.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
 [file m/__init__.py]
 [file m/n.py]
 def f(): pass
@@ -647,7 +647,7 @@ def f(): pass
 [case testAssignToFuncDefViaModule]
 import m
 m.f = None
-m.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type Callable[[], Any])
+m.f = 1 # E: Incompatible types in assignment (expression has type "int", variable has type "Callable[[], Any]")
 [file m.py]
 def f(): pass
 [out]
@@ -692,7 +692,7 @@ def f(x: str) -> None: pass
 None + 1
 [file m/a.py]
 [out]
-tmp/m/__init__.py:1: error: Unsupported left operand type for + (None)
+tmp/m/__init__.py:1: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckNamedModule2]
 # cmd: mypy -m m.a
@@ -700,7 +700,7 @@ tmp/m/__init__.py:1: error: Unsupported left operand type for + (None)
 [file m/a.py]
 None + 1
 [out]
-tmp/m/a.py:1: error: Unsupported left operand type for + (None)
+tmp/m/a.py:1: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckNamedModule3]
 # cmd: mypy -m m
@@ -708,7 +708,7 @@ tmp/m/a.py:1: error: Unsupported left operand type for + (None)
 None + 1
 [file m/a.py]
 [out]
-tmp/m/__init__.py:1: error: Unsupported left operand type for + (None)
+tmp/m/__init__.py:1: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckNamedModule4]
 # cmd: mypy -m m
@@ -723,7 +723,7 @@ None + ''  # Not analyzed.
 [file m.py]
 None + 1
 [out]
-tmp/m.py:1: error: Unsupported left operand type for + (None)
+tmp/m.py:1: error: Unsupported left operand type for + ("None")
 
 [case testTypeCheckNamedModuleWithImportCycle]
 # cmd: mypy -m m.a
@@ -933,8 +933,8 @@ def y() -> str: return "foo"
 class z: pass
 [out]
 main:2: error: Incompatible import of "x" (imported name has type "str", local name has type "int")
-main:2: error: Incompatible import of "y" (imported name has type Callable[[], str], local name has type Callable[[], int])
-main:2: error: Incompatible import of "z" (imported name has type Type[b.z], local name has type Type[a.z])
+main:2: error: Incompatible import of "y" (imported name has type "Callable[[], str]", local name has type "Callable[[], int]")
+main:2: error: Incompatible import of "z" (imported name has type "Type[b.z]", local name has type "Type[a.z]")
 
 -- Misc
 
@@ -1937,4 +1937,4 @@ main:2: error: Revealed type is 'Any'
 main:2: error: Name 'name' is not defined
 main:3: error: Revealed type is 'Any'
 
-[builtins fixtures/module.pyi]
\ No newline at end of file
+[builtins fixtures/module.pyi]
diff --git a/test-data/unit/check-namedtuple.test b/test-data/unit/check-namedtuple.test
--- a/test-data/unit/check-namedtuple.test
+++ b/test-data/unit/check-namedtuple.test
@@ -221,7 +221,7 @@ a = (1,)  # E: Incompatible types in assignment (expression has type "Tuple[int]
 [case testNamedTupleMissingClassAttribute]
 import collections
 MyNamedTuple = collections.namedtuple('MyNamedTuple', ['spam', 'eggs'])
-MyNamedTuple.x # E: Type[MyNamedTuple] has no attribute "x"
+MyNamedTuple.x # E: "Type[MyNamedTuple]" has no attribute "x"
 
 
 [case testNamedTupleEmptyItems]
@@ -286,7 +286,7 @@ from typing import NamedTuple
 
 X = NamedTuple('X', [('x', int), ('y', str)])
 reveal_type(X._make([5, 'a']))  # E: Revealed type is 'Tuple[builtins.int, builtins.str, fallback=__main__.X]'
-X._make('a b')  # E: Argument 1 to X._make has incompatible type "str"; expected Iterable[Any]
+X._make('a b')  # E: Argument 1 to X._make has incompatible type "str"; expected "Iterable[Any]"
 
 -- # FIX: not a proper class method
 -- x = None  # type: X
@@ -415,7 +415,7 @@ b = B._make([''])  # type: B
 [case testNamedTupleIncompatibleRedefinition]
 from typing import NamedTuple
 class Crash(NamedTuple):
-    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as Callable[[Tuple[Any, ...], Any], int])
+    count: int  # E: Incompatible types in assignment (expression has type "int", base class "tuple" defined the type as "Callable[[Tuple[Any, ...], Any], int]")
 [builtins fixtures/tuple.pyi]
 
 [case testNamedTupleInClassNamespace]
@@ -426,7 +426,7 @@ class C:
         A = NamedTuple('A', [('x', int)])
     def g(self):
         A = NamedTuple('A', [('y', int)])
-C.A  # E: Type[C] has no attribute "A"
+C.A  # E: "Type[C]" has no attribute "A"
 
 [case testNamedTupleInFunction]
 from typing import NamedTuple
diff --git a/test-data/unit/check-newsyntax.test b/test-data/unit/check-newsyntax.test
--- a/test-data/unit/check-newsyntax.test
+++ b/test-data/unit/check-newsyntax.test
@@ -29,7 +29,7 @@ from typing import Dict, Any
 d: Dict[int, str] = {}
 d[42] = 'ab'
 d[42] = 42  # E: Incompatible types in assignment (expression has type "int", target has type "str")
-d['ab'] = 'ab'  # E: Invalid index type "str" for Dict[int, str]; expected type "int"
+d['ab'] = 'ab'  # E: Invalid index type "str" for "Dict[int, str]"; expected type "int"
 [builtins fixtures/dict.pyi]
 [out]
 
@@ -61,29 +61,29 @@ TstInstance().a = 'ab'
 [case testNewSyntaxWithClassVars]
 # flags: --strict-optional --python-version 3.6
 class CCC:
-    a: str = None  # E: Incompatible types in assignment (expression has type None, variable has type "str")
+    a: str = None  # E: Incompatible types in assignment (expression has type "None", variable has type "str")
 [out]
 
 [case testNewSyntaxWithStrictOptional]
 # flags: --strict-optional --python-version 3.6
 strict: int
-strict = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
-strict2: int = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+strict = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
+strict2: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 [out]
 
 [case testNewSyntaxWithStrictOptionalFunctions]
 # flags: --strict-optional --python-version 3.6
 def f() -> None:
     x: int
-    x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+    x = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 [out]
 
 [case testNewSyntaxWithStrictOptionalClasses]
 # flags: --strict-optional --python-version 3.6
 class C:
     def meth(self) -> None:
-        x: int = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
-        self.x: int = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+        x: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
+        self.x: int = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 [out]
 
 [case testNewSyntaxSpecialAssign]
diff --git a/test-data/unit/check-optional.test b/test-data/unit/check-optional.test
--- a/test-data/unit/check-optional.test
+++ b/test-data/unit/check-optional.test
@@ -2,11 +2,11 @@
 
 [case testImplicitNoneType]
 x = None
-x()  # E: None not callable
+x()  # E: "None" not callable
 
 [case testExplicitNoneType]
 x = None  # type: None
-x()  # E: None not callable
+x()  # E: "None" not callable
 
 [case testNoneMemberOfOptional]
 from typing import Optional
@@ -19,12 +19,12 @@ x = 0  # type: Optional[int]
 [case testNoneNotMemberOfType]
 x = None  # type: int
 [out]
-main:1: error: Incompatible types in assignment (expression has type None, variable has type "int")
+main:1: error: Incompatible types in assignment (expression has type "None", variable has type "int")
 
 [case testTypeNotMemberOfNone]
 x = 0  # type: None
 [out]
-main:1: error: Incompatible types in assignment (expression has type "int", variable has type None)
+main:1: error: Incompatible types in assignment (expression has type "int", variable has type "None")
 
 [case testOptionalNotMemberOfType]
 from typing import Optional
@@ -127,7 +127,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNone]
 # flags: --no-implicit-optional
-def f(x: int = None) -> None:  # E: Incompatible default for argument "x" (default has type None, argument has type "int")
+def f(x: int = None) -> None:  # E: Incompatible default for argument "x" (default has type "None", argument has type "int")
   pass
 [out]
 
@@ -140,7 +140,7 @@ f(None)
 
 [case testNoInferOptionalFromDefaultNoneComment]
 # flags: --no-implicit-optional
-def f(x=None):  # E: Incompatible default for argument "x" (default has type None, argument has type "int")
+def f(x=None):  # E: Incompatible default for argument "x" (default has type "None", argument has type "int")
   # type: (int) -> None
   pass
 [out]
@@ -180,13 +180,13 @@ reveal_type(x)  # E: Revealed type is 'Union[builtins.int, builtins.None]'
 
 [case testInferOptionalListType]
 x = [None]
-x.append(1)  # E: Argument 1 to "append" of "list" has incompatible type "int"; expected None
+x.append(1)  # E: Argument 1 to "append" of "list" has incompatible type "int"; expected "None"
 [builtins fixtures/list.pyi]
 
 [case testInferNonOptionalListType]
 x = []
 x.append(1)
-x()  # E: List[int] not callable
+x()  # E: "List[int]" not callable
 [builtins fixtures/list.pyi]
 
 [case testInferOptionalDictKeyValueTypes]
@@ -194,13 +194,13 @@ x = {None: None}
 x["bar"] = 1
 [builtins fixtures/dict.pyi]
 [out]
-main:2: error: Invalid index type "str" for Dict[None, None]; expected type None
-main:2: error: Incompatible types in assignment (expression has type "int", target has type None)
+main:2: error: Invalid index type "str" for "Dict[None, None]"; expected type "None"
+main:2: error: Incompatible types in assignment (expression has type "int", target has type "None")
 
 [case testInferNonOptionalDictType]
 x = {}
 x["bar"] = 1
-x()  # E: Dict[str, int] not callable
+x()  # E: "Dict[str, int]" not callable
 [builtins fixtures/dict.pyi]
 
 [case testNoneClassVariable]
@@ -215,7 +215,7 @@ from typing import Optional
 class C:
     x = None  # type: int
     def __init__(self) -> None:
-        self.x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
+        self.x = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
 [out]
 
 [case testMultipleAssignmentNoneClassVariableInInit]
@@ -223,8 +223,8 @@ from typing import Optional
 class C:
     x, y = None, None  # type: int, str
     def __init__(self) -> None:
-        self.x = None  # E: Incompatible types in assignment (expression has type None, variable has type "int")
-        self.y = None  # E: Incompatible types in assignment (expression has type None, variable has type "str")
+        self.x = None  # E: Incompatible types in assignment (expression has type "None", variable has type "int")
+        self.y = None  # E: Incompatible types in assignment (expression has type "None", variable has type "str")
 [out]
 
 [case testOverloadWithNone]
@@ -455,7 +455,7 @@ reveal_type(l)  # E: Revealed type is 'builtins.list[typing.Generator*[builtins.
 [builtins fixtures/list.pyi]
 
 [case testNoneListTernary]
-x = [None] if "" else [1]  # E: List item 0 has incompatible type "int"; expected None
+x = [None] if "" else [1]  # E: List item 0 has incompatible type "int"; expected "None"
 [builtins fixtures/list.pyi]
 
 [case testListIncompatibleErrorMessage]
@@ -465,7 +465,7 @@ def foo(l: List[Callable[[], str]]) -> None: pass
 def f() -> int:
     return 42
 
-foo([f])  # E: List item 0 has incompatible type Callable[[], int]; expected Callable[[], str]
+foo([f])  # E: List item 0 has incompatible type "Callable[[], int]"; expected "Callable[[], str]"
 [builtins fixtures/list.pyi]
 
 [case testInferEqualsNotOptional]
diff --git a/test-data/unit/check-overloading.test b/test-data/unit/check-overloading.test
--- a/test-data/unit/check-overloading.test
+++ b/test-data/unit/check-overloading.test
@@ -447,7 +447,7 @@ from foo import *
 from typing import overload
 t, a = None, None # type: (type, A)
 
-a = A # E: Incompatible types in assignment (expression has type Type[A], variable has type "A")
+a = A # E: Incompatible types in assignment (expression has type "Type[A]", variable has type "A")
 t = A
 
 class A:
@@ -610,7 +610,7 @@ n = 1
 m = 1
 n = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
 m = 'x' # E: Incompatible types in assignment (expression has type "str", variable has type "int")
-f(list_object) # E: Argument 1 to "f" has incompatible type List[object]; expected List[int]
+f(list_object) # E: Argument 1 to "f" has incompatible type "List[object]"; expected "List[int]"
 [builtins fixtures/list.pyi]
 
 [case testOverlappingOverloadSignatures]
@@ -901,7 +901,7 @@ def f(x: int, y: List[int] = None) -> int: pass
 def f(x: int, y: List[str] = None) -> int: pass
 f(y=[1], x=0)() # E: "int" not callable
 f(y=[''], x=0)() # E: "int" not callable
-a = f(y=[['']], x=0) # E: List item 0 has incompatible type List[str]; expected "int"
+a = f(y=[['']], x=0) # E: List item 0 has incompatible type "List[str]"; expected "int"
 a() # E: "int" not callable
 [builtins fixtures/list.pyi]
 
@@ -1117,14 +1117,14 @@ def f(x: int, y: Tuple[str, ...]) -> None: pass
 @overload
 def f(x: int, y: str) -> None: pass
 f(1, ('2', '3'))
-f(1, (2, '3')) # E: Argument 2 to "f" has incompatible type "Tuple[int, str]"; expected Tuple[str, ...]
+f(1, (2, '3')) # E: Argument 2 to "f" has incompatible type "Tuple[int, str]"; expected "Tuple[str, ...]"
 f(1, ('2',))
 f(1, '2')
-f(1, (2, 3)) # E: Argument 2 to "f" has incompatible type "Tuple[int, int]"; expected Tuple[str, ...]
+f(1, (2, 3)) # E: Argument 2 to "f" has incompatible type "Tuple[int, int]"; expected "Tuple[str, ...]"
 x = ('2', '3')  # type: Tuple[str, ...]
 f(1, x)
 y = (2, 3)  # type: Tuple[int, ...]
-f(1, y) # E: Argument 2 to "f" has incompatible type Tuple[int, ...]; expected Tuple[str, ...]
+f(1, y) # E: Argument 2 to "f" has incompatible type "Tuple[int, ...]"; expected "Tuple[str, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testCallableSpecificOverload]
diff --git a/test-data/unit/check-protocols.test b/test-data/unit/check-protocols.test
--- a/test-data/unit/check-protocols.test
+++ b/test-data/unit/check-protocols.test
@@ -197,7 +197,7 @@ class C:
     meth: int
 x: P = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P") \
            # N: Following member(s) of "C" have conflicts: \
-           # N:     meth: expected Callable[[], int], got "int"
+           # N:     meth: expected "Callable[[], int]", got "int"
 
 [case testProtocolMethodVsAttributeErrors2]
 from typing import Protocol
@@ -211,7 +211,7 @@ class C:
         pass
 x: P = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P") \
            # N: Following member(s) of "C" have conflicts: \
-           # N:     meth: expected "int", got Callable[[], int]
+           # N:     meth: expected "int", got "Callable[[], int]"
 [builtins fixtures/property.pyi]
 
 [case testCannotAssignNormalToProtocol]
@@ -272,7 +272,7 @@ class MyHashable(Protocol):
 
 class C(MyHashable):
     __my_hash__ = None  # E: Incompatible types in assignment \
-(expression has type None, base class "MyHashable" defined the type as Callable[[MyHashable], int])
+(expression has type "None", base class "MyHashable" defined the type as "Callable[[MyHashable], int]")
 
 [case testProtocolsWithNoneAndStrictOptional]
 # flags: --strict-optional
@@ -289,10 +289,10 @@ f(C()) # Error!
 [out]
 main:9: error: Incompatible types in assignment (expression has type "C", variable has type "P")
 main:9: note: Following member(s) of "C" have conflicts:
-main:9: note:     x: expected "int", got None
+main:9: note:     x: expected "int", got "None"
 main:11: error: Argument 1 to "f" has incompatible type "C"; expected "P"
 main:11: note: Following member(s) of "C" have conflicts:
-main:11: note:     x: expected "int", got None
+main:11: note:     x: expected "int", got "None"
 
 -- Semanal errors in protocol types
 -- --------------------------------
@@ -442,18 +442,18 @@ class B(A): pass
 
 x1: Pco[B]
 y1: Pco[A]
-x1 = y1 # E: Incompatible types in assignment (expression has type Pco[A], variable has type Pco[B])
-y1 = x1 # E: Incompatible types in assignment (expression has type Pco[B], variable has type Pco[A])
+x1 = y1 # E: Incompatible types in assignment (expression has type "Pco[A]", variable has type "Pco[B]")
+y1 = x1 # E: Incompatible types in assignment (expression has type "Pco[B]", variable has type "Pco[A]")
 
 x2: Pcontra[B]
 y2: Pcontra[A]
-y2 = x2 # E: Incompatible types in assignment (expression has type Pcontra[B], variable has type Pcontra[A])
-x2 = y2 # E: Incompatible types in assignment (expression has type Pcontra[A], variable has type Pcontra[B])
+y2 = x2 # E: Incompatible types in assignment (expression has type "Pcontra[B]", variable has type "Pcontra[A]")
+x2 = y2 # E: Incompatible types in assignment (expression has type "Pcontra[A]", variable has type "Pcontra[B]")
 
 x3: Pinv[B]
 y3: Pinv[A]
-y3 = x3 # E: Incompatible types in assignment (expression has type Pinv[B], variable has type Pinv[A])
-x3 = y3 # E: Incompatible types in assignment (expression has type Pinv[A], variable has type Pinv[B])
+y3 = x3 # E: Incompatible types in assignment (expression has type "Pinv[B]", variable has type "Pinv[A]")
+x3 = y3 # E: Incompatible types in assignment (expression has type "Pinv[A]", variable has type "Pinv[B]")
 
 [case testProtocolVarianceWithCallableAndList]
 from typing import Protocol, TypeVar, Callable, List
@@ -586,7 +586,7 @@ class C:
 
 c: C
 var: P2[int, int] = c
-var2: P2[int, str] = c # E: Incompatible types in assignment (expression has type "C", variable has type P2[int, str]) \
+var2: P2[int, str] = c # E: Incompatible types in assignment (expression has type "C", variable has type "P2[int, str]") \
                        # N: Following member(s) of "C" have conflicts: \
                        # N:     attr2: expected "Tuple[int, str]", got "Tuple[int, int]"
 
@@ -597,7 +597,7 @@ class E(D[T]):
 
 def f(x: T) -> T:
     z: P2[T, T] = E[T]()
-    y: P2[T, T] = D[T]() # E: Incompatible types in assignment (expression has type D[T], variable has type P2[T, T]) \
+    y: P2[T, T] = D[T]() # E: Incompatible types in assignment (expression has type "D[T]", variable has type "P2[T, T]") \
                          # N: 'D' is missing following 'P2' protocol member: \
                          # N:     attr2
     return x
@@ -628,7 +628,7 @@ class D(A, B): pass
 
 x: P = D()  # Same as P[Any, Any]
 
-var: P[Union[int, P], Union[P, str]] = C() # E: Incompatible types in assignment (expression has type "C", variable has type P[Union[int, P[Any, Any]], Union[P[Any, Any], str]]) \
+var: P[Union[int, P], Union[P, str]] = C() # E: Incompatible types in assignment (expression has type "C", variable has type "P[Union[int, P[Any, Any]], Union[P[Any, Any], str]]") \
                                            # N: Following member(s) of "C" have conflicts: \
                                            # N:     attr1: expected "Union[int, P[Any, Any]]", got "int" \
                                            # N:     attr2: expected "Union[P[Any, Any], str]", got "str"
@@ -653,7 +653,7 @@ class C:
 var: P[Union[int, P], Union[P, str]] = C() # OK for covariant
 var2: P[Union[str, P], Union[P, int]] = C()
 [out]
-main:18: error: Incompatible types in assignment (expression has type "C", variable has type P[Union[str, P[Any, Any]], Union[P[Any, Any], int]])
+main:18: error: Incompatible types in assignment (expression has type "C", variable has type "P[Union[str, P[Any, Any]], Union[P[Any, Any], int]]")
 main:18: note: Following member(s) of "C" have conflicts:
 main:18: note:     Expected:
 main:18: note:         def attr1(self) -> Union[str, P[Any, Any]]
@@ -799,7 +799,7 @@ class L:
 
 def last(seq: Linked[T]) -> T:
     pass
-last(L()) # E: Argument 1 to "last" has incompatible type "L"; expected Linked[<nothing>]
+last(L()) # E: Argument 1 to "last" has incompatible type "L"; expected "Linked[<nothing>]"
 
 [case testMutuallyRecursiveProtocols]
 from typing import Protocol, Sequence, List
@@ -842,7 +842,7 @@ class B:
 t: P1
 t = A() # E: Incompatible types in assignment (expression has type "A", variable has type "P1") \
         # N: Following member(s) of "A" have conflicts: \
-        # N:     attr1: expected Sequence[P2], got List[B]
+        # N:     attr1: expected "Sequence[P2]", got "List[B]"
 [builtins fixtures/list.pyi]
 
 [case testMutuallyRecursiveProtocolsTypesWithSubteMismatchWriteable]
@@ -1385,13 +1385,13 @@ def f(cls: Type[P]) -> P:
 def g() -> P:
     return P()  # E: Cannot instantiate protocol class "P"
 
-f(P)  # E: Only concrete class can be given where 'Type[P]' is expected
+f(P)  # E: Only concrete class can be given where "Type[P]" is expected
 f(B)  # OK
 f(C)  # OK
 x: Type[P1]
 xbad: Type[Pbad]
 f(x)  # OK
-f(xbad)  # E: Argument 1 to "f" has incompatible type Type[Pbad]; expected Type[P]
+f(xbad)  # E: Argument 1 to "f" has incompatible type "Type[Pbad]"; expected "Type[P]"
 
 [case testInstantiationProtocolInTypeForAliases]
 from typing import Type, Protocol
@@ -1409,7 +1409,7 @@ Alias = P
 GoodAlias = C
 Alias()  # E: Cannot instantiate protocol class "P"
 GoodAlias()
-f(Alias)  # E: Only concrete class can be given where 'Type[P]' is expected
+f(Alias)  # E: Only concrete class can be given where "Type[P]" is expected
 f(GoodAlias)
 
 [case testInstantiationProtocolInTypeForVariables]
@@ -1424,13 +1424,13 @@ class C:
 
 var: Type[P]
 var()
-var = P # E: Can only assign concrete classes to a variable of type 'Type[P]'
+var = P # E: Can only assign concrete classes to a variable of type "Type[P]"
 var = B # OK
 var = C # OK
 
 var_old = None # type: Type[P] # Old syntax for variable annotations
 var_old()
-var_old = P # E: Can only assign concrete classes to a variable of type 'Type[P]'
+var_old = P # E: Can only assign concrete classes to a variable of type "Type[P]"
 var_old = B # OK
 var_old = C # OK
 
@@ -1596,7 +1596,7 @@ def f(x: MyProto[int]) -> None:
 f(t)  # OK
 
 y: MyProto[str]
-y = t # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type MyProto[str])
+y = t # E: Incompatible types in assignment (expression has type "Tuple[int, str]", variable has type "MyProto[str]")
 [builtins fixtures/isinstancelist.pyi]
 
 [case testBasicNamedTupleStructuralSubtyping]
@@ -1631,11 +1631,11 @@ def fun3(x: P[T, T]) -> T:
     return x.x
 
 fun(z)
-fun2(z) # E: Argument 1 to "fun2" has incompatible type "N"; expected P[int, int] \
+fun2(z) # E: Argument 1 to "fun2" has incompatible type "N"; expected "P[int, int]" \
         # N: Following member(s) of "N" have conflicts: \
         # N:     y: expected "int", got "str"
 
-fun(N2(1)) # E: Argument 1 to "fun" has incompatible type "N2"; expected P[int, str] \
+fun(N2(1)) # E: Argument 1 to "fun" has incompatible type "N2"; expected "P[int, str]" \
            # N: 'N2' is missing following 'P' protocol member: \
            # N:     y
 
@@ -1663,8 +1663,8 @@ def apply_gen(f: Callable[[T], T]) -> T:
 reveal_type(apply_gen(Add5())) # E: Revealed type is 'builtins.int*'
 def apply_str(f: Callable[[str], int], x: str) -> int:
     return f(x)
-apply_str(Add5(), 'a') # E: Argument 1 to "apply_str" has incompatible type "Add5"; expected Callable[[str], int] \
-                       # N: 'Add5.__call__' has type 'Callable[[Arg(int, 'x')], int]'
+apply_str(Add5(), 'a') # E: Argument 1 to "apply_str" has incompatible type "Add5"; expected "Callable[[str], int]" \
+                       # N: 'Add5.__call__' has type "Callable[[Arg(int, 'x')], int]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testMoreComplexCallableStructuralSubtyping]
@@ -1680,10 +1680,10 @@ class Bad1:
 class Bad2:
     def __call__(self, y: int, *rest: str) -> int: pass
 call_soon(Good())
-call_soon(Bad1()) # E: Argument 1 to "call_soon" has incompatible type "Bad1"; expected Callable[[int, VarArg(str)], int] \
-                  # N: 'Bad1.__call__' has type 'Callable[[Arg(int, 'x'), VarArg(int)], int]'
-call_soon(Bad2()) # E: Argument 1 to "call_soon" has incompatible type "Bad2"; expected Callable[[int, VarArg(str)], int] \
-                  # N: 'Bad2.__call__' has type 'Callable[[Arg(int, 'y'), VarArg(str)], int]'
+call_soon(Bad1()) # E: Argument 1 to "call_soon" has incompatible type "Bad1"; expected "Callable[[int, VarArg(str)], int]" \
+                  # N: 'Bad1.__call__' has type "Callable[[Arg(int, 'x'), VarArg(int)], int]"
+call_soon(Bad2()) # E: Argument 1 to "call_soon" has incompatible type "Bad2"; expected "Callable[[int, VarArg(str)], int]" \
+                  # N: 'Bad2.__call__' has type "Callable[[Arg(int, 'y'), VarArg(str)], int]"
 [builtins fixtures/isinstancelist.pyi]
 
 [case testStructuralSupportForPartial]
@@ -1783,7 +1783,7 @@ f1(C1())
 f2(C2())
 f3(C3())
 
-f2(C3())  # E: Argument 1 to "f2" has incompatible type "C3"; expected P2[str]
+f2(C3())  # E: Argument 1 to "f2" has incompatible type "C3"; expected "P2[str]"
 a: Any
 f1(a)
 f2(a)
@@ -2042,8 +2042,8 @@ def f1(x: Iterable[str]) -> None: pass
 def f2(x: Sequence[str]) -> None: pass
 
 # The errors below should be short
-f1(N(1))  # E: Argument 1 to "f1" has incompatible type "N"; expected Iterable[str]
-f2(N(2))  # E: Argument 1 to "f2" has incompatible type "N"; expected Sequence[str]
+f1(N(1))  # E: Argument 1 to "f1" has incompatible type "N"; expected "Iterable[str]"
+f2(N(2))  # E: Argument 1 to "f2" has incompatible type "N"; expected "Sequence[str]"
 [builtins fixtures/tuple.pyi]
 
 [case testNotManyFlagConflitsShownInProtocols]
@@ -2092,7 +2092,7 @@ class MockDict(MockMapping[T]):
 
 def f(x: MockMapping[int]) -> None: pass
 x: MockDict[str]
-f(x)  # E: Argument 1 to "f" has incompatible type MockDict[str]; expected MockMapping[int]
+f(x)  # E: Argument 1 to "f" has incompatible type "MockDict[str]"; expected "MockMapping[int]"
 
 [case testProtocolNotesForComplexSignatures]
 from typing import Protocol, Optional
diff --git a/test-data/unit/check-python2.test b/test-data/unit/check-python2.test
--- a/test-data/unit/check-python2.test
+++ b/test-data/unit/check-python2.test
@@ -34,7 +34,7 @@ class A:
 print >>A(), ''
 print >>None, ''
 print >>1, '' # E: "int" has no attribute "write"
-print >>(None + ''), None # E: Unsupported left operand type for + (None)
+print >>(None + ''), None # E: Unsupported left operand type for + ("None")
 
 [case testDivision]
 class A:
@@ -291,7 +291,7 @@ class A(object):
     __metaclass__ = M
     y = 0
 reveal_type(A.y) # E: Revealed type is 'builtins.int'
-A.x # E: Type[A] has no attribute "x"
+A.x # E: "Type[A]" has no attribute "x"
 
 [case testAnyAsBaseOfMetaclass]
 from typing import Any, Type
diff --git a/test-data/unit/check-serialize.test b/test-data/unit/check-serialize.test
--- a/test-data/unit/check-serialize.test
+++ b/test-data/unit/check-serialize.test
@@ -662,7 +662,7 @@ class A: pass
 def f() -> None: pass
 [builtins fixtures/tuple.pyi]
 [out2]
-tmp/a.py:4: error: Incompatible types in assignment (expression has type Callable[[], None], variable has type "type")
+tmp/a.py:4: error: Incompatible types in assignment (expression has type "Callable[[], None]", variable has type "type")
 
 [case testSerializeOverloadedVsTypeObjectDistinction]
 import a
diff --git a/test-data/unit/check-statements.test b/test-data/unit/check-statements.test
--- a/test-data/unit/check-statements.test
+++ b/test-data/unit/check-statements.test
@@ -377,7 +377,7 @@ import typing
 assert None + None # Fail
 assert None
 [out]
-main:2: error: Unsupported left operand type for + (None)
+main:2: error: Unsupported left operand type for + ("None")
 
 
 -- Exception handling
@@ -594,14 +594,14 @@ else:
     def f3() -> None: pass
 [builtins fixtures/exception.pyi]
 [out]
-main:7: error: Incompatible redefinition (redefinition with type Callable[[], str], original type Callable[[], None])
+main:7: error: Incompatible redefinition (redefinition with type "Callable[[], str]", original type "Callable[[], None]")
 
 [case testExceptWithoutType]
 import typing
 try:
-    -None # E: Unsupported operand type for unary - (None)
+    -None # E: Unsupported operand type for unary - ("None")
 except:
-    ~None # E: Unsupported operand type for ~ (None)
+    ~None # E: Unsupported operand type for ~ ("None")
 [builtins fixtures/exception.pyi]
 
 [case testRaiseWithoutArgument]
@@ -1188,7 +1188,7 @@ def g() -> Iterator[List[int]]:
     yield [2, 3, 4]
 def f() -> Iterator[List[int]]:
     yield from g()
-    yield from [1, 2, 3]  # E: Incompatible types in "yield from" (actual type "int", expected type List[int])
+    yield from [1, 2, 3]  # E: Incompatible types in "yield from" (actual type "int", expected type "List[int]")
 [builtins fixtures/for.pyi]
 [out]
 
@@ -1437,7 +1437,7 @@ y = 1
 from typing import List
 bs, cs = None, None # type: List[A], List[B]
 *bs, b = bs
-*bs, c = cs  # E: Incompatible types in assignment (expression has type List[B], variable has type List[A])
+*bs, c = cs  # E: Incompatible types in assignment (expression has type "List[B]", variable has type "List[A]")
 *ns, c = cs
 nc = cs
 
diff --git a/test-data/unit/check-tuples.test b/test-data/unit/check-tuples.test
--- a/test-data/unit/check-tuples.test
+++ b/test-data/unit/check-tuples.test
@@ -91,7 +91,7 @@ from typing import Tuple
 t1 = None # type: Tuple[A, A]
 t2 = None # type: tuple
 
-t1 = t2 # E: Incompatible types in assignment (expression has type Tuple[Any, ...], variable has type "Tuple[A, A]")
+t1 = t2 # E: Incompatible types in assignment (expression has type "Tuple[Any, ...]", variable has type "Tuple[A, A]")
 t2 = t1
 
 class A: pass
@@ -388,7 +388,7 @@ aa, bb, *cc = t  # E: Need type annotation for variable
 from typing import List
 li, lo = None, None # type: List[int], List[object]
 a, b, *c = 1, 2  # type: int, int, List[int]
-c = lo  # E: Incompatible types in assignment (expression has type List[object], variable has type List[int])
+c = lo  # E: Incompatible types in assignment (expression has type "List[object]", variable has type "List[int]")
 c = li
 [builtins fixtures/list.pyi]
 
@@ -450,14 +450,14 @@ class A: pass
 [out]
 main:6: error: List item 0 has incompatible type "A"; expected "int"
 main:6: error: List item 1 has incompatible type "A"; expected "int"
-main:9: error: Incompatible types in assignment (expression has type "A", variable has type List[A])
+main:9: error: Incompatible types in assignment (expression has type "A", variable has type "List[A]")
 
 [case testAssignmentToStarFromTupleInference]
 from typing import List
 li = None # type: List[int]
 la = None # type: List[A]
 a, *l = A(), A()
-l = li  # E: Incompatible types in assignment (expression has type List[int], variable has type List[A])
+l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
 l = la
 
 class A: pass
@@ -469,7 +469,7 @@ from typing import List
 li = None # type: List[int]
 la = None # type: List[A]
 a, *l = [A(), A()]
-l = li  # E: Incompatible types in assignment (expression has type List[int], variable has type List[A])
+l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
 l = la
 
 class A: pass
@@ -482,7 +482,7 @@ li = None # type: List[int]
 la = None # type: List[A]
 ta = None # type: Tuple[A, A, A]
 a, *l = ta
-l = li  # E: Incompatible types in assignment (expression has type List[int], variable has type List[A])
+l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
 l = la
 
 class A: pass
@@ -494,7 +494,7 @@ from typing import List
 li = None # type: List[int]
 la = None # type: List[A]
 a, *l = la
-l = li  # E: Incompatible types in assignment (expression has type List[int], variable has type List[A])
+l = li  # E: Incompatible types in assignment (expression has type "List[int]", variable has type "List[A]")
 l = la
 
 class A: pass
@@ -750,7 +750,7 @@ tb = () # type: Tuple[B, ...]
 fa(ta)
 fa(tb)
 fb(tb)
-fb(ta) # E: Argument 1 to "fb" has incompatible type Tuple[A, ...]; expected Tuple[B, ...]
+fb(ta) # E: Argument 1 to "fb" has incompatible type "Tuple[A, ...]"; expected "Tuple[B, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testSubtypingFixedAndVariableLengthTuples]
@@ -766,8 +766,8 @@ fa(aa)
 fa(ab)
 fa(bb)
 fb(bb)
-fb(ab) # E: Argument 1 to "fb" has incompatible type "Tuple[A, B]"; expected Tuple[B, ...]
-fb(aa) # E: Argument 1 to "fb" has incompatible type "Tuple[A, A]"; expected Tuple[B, ...]
+fb(ab) # E: Argument 1 to "fb" has incompatible type "Tuple[A, B]"; expected "Tuple[B, ...]"
+fb(aa) # E: Argument 1 to "fb" has incompatible type "Tuple[A, A]"; expected "Tuple[B, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testSubtypingTupleIsContainer]
@@ -913,7 +913,7 @@ def f(a: Tuple) -> None: pass
 f(())
 f((1,))
 f(('', ''))
-f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected Tuple[Any, ...]
+f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected "Tuple[Any, ...]"
 [builtins fixtures/tuple.pyi]
 
 [case testTupleSingleton]
diff --git a/test-data/unit/check-type-checks.test b/test-data/unit/check-type-checks.test
--- a/test-data/unit/check-type-checks.test
+++ b/test-data/unit/check-type-checks.test
@@ -107,7 +107,7 @@ def f(x: object) -> None:
     if isinstance(x, C):
         x.f(1)
         x.f('')
-        x.g() # E: C[Any] has no attribute "g"
+        x.g() # E: "C[Any]" has no attribute "g"
     x.g() # E: "object" has no attribute "g"
 [builtins fixtures/isinstance.pyi]
 [out]
diff --git a/test-data/unit/check-typeddict.test b/test-data/unit/check-typeddict.test
--- a/test-data/unit/check-typeddict.test
+++ b/test-data/unit/check-typeddict.test
@@ -295,7 +295,7 @@ from mypy_extensions import TypedDict
 from typing import Mapping
 Point = TypedDict('Point', {'x': int, 'y': int})
 def as_mapping(p: Point) -> Mapping[str, str]:
-    return p  # E: Incompatible return value type (got "Point", expected Mapping[str, str])
+    return p  # E: Incompatible return value type (got "Point", expected "Mapping[str, str]")
 [builtins fixtures/dict.pyi]
 
 [case testTypedDictAcceptsIntForFloatDuckTypes]
@@ -341,9 +341,9 @@ from mypy_extensions import TypedDict
 from typing import Dict, MutableMapping
 Point = TypedDict('Point', {'x': int, 'y': int})
 def as_dict(p: Point) -> Dict[str, int]:
-    return p  # E: Incompatible return value type (got "Point", expected Dict[str, int])
+    return p  # E: Incompatible return value type (got "Point", expected "Dict[str, int]")
 def as_mutable_mapping(p: Point) -> MutableMapping[str, int]:
-    return p  # E: Incompatible return value type (got "Point", expected MutableMapping[str, int]) \
+    return p  # E: Incompatible return value type (got "Point", expected "MutableMapping[str, int]") \
               # N: 'Point' is missing following 'MutableMapping' protocol member: \
               # N:     __setitem__
 [builtins fixtures/dict.pyi]
@@ -369,9 +369,9 @@ c: C
 def f(a: A) -> None: pass
 
 l = [a, b]  # Join generates an anonymous TypedDict
-f(l) # E: Argument 1 to "f" has incompatible type List[TypedDict({'x': int})]; expected "A"
+f(l) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x': int})]"; expected "A"
 ll = [b, c]
-f(ll) # E: Argument 1 to "f" has incompatible type List[TypedDict({'x': int, 'z': str})]; expected "A"
+f(ll) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x': int, 'z': str})]"; expected "A"
 [builtins fixtures/dict.pyi]
 
 [case testTypedDictWithSimpleProtocol]
@@ -741,7 +741,7 @@ class C:
         A = TypedDict('A', {'x': int})
     def g(self):
         A = TypedDict('A', {'y': int})
-C.A  # E: Type[C] has no attribute "A"
+C.A  # E: "Type[C]" has no attribute "A"
 [builtins fixtures/dict.pyi]
 
 [case testTypedDictInFunction]
@@ -1096,9 +1096,9 @@ c: C
 def f(a: A) -> None: pass
 
 l = [a, b]  # Join generates an anonymous TypedDict
-f(l) # E: Argument 1 to "f" has incompatible type List[TypedDict({'x'?: int})]; expected "A"
+f(l) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x'?: int})]"; expected "A"
 ll = [b, c]
-f(ll) # E: Argument 1 to "f" has incompatible type List[TypedDict({'x'?: int, 'z'?: str})]; expected "A"
+f(ll) # E: Argument 1 to "f" has incompatible type "List[TypedDict({'x'?: int, 'z'?: str})]"; expected "A"
 [builtins fixtures/dict.pyi]
 
 
@@ -1184,7 +1184,7 @@ f(a)
 [builtins fixtures/dict.pyi]
 [typing fixtures/typing-full.pyi]
 [out]
-main:13: error: Argument 1 to "f" has incompatible type "A"; expected Iterable[int]
+main:13: error: Argument 1 to "f" has incompatible type "A"; expected "Iterable[int]"
 main:13: note: Following member(s) of "A" have conflicts:
 main:13: note:     Expected:
 main:13: note:         def __iter__(self) -> Iterator[int]
@@ -1284,7 +1284,7 @@ class C(B): pass
 x: X
 reveal_type(x) # E: Revealed type is 'TypedDict('__main__.X', {'b': __main__.B, 'c': __main__.C})'
 m1: Mapping[str, B] = x
-m2: Mapping[str, C] = x # E: Incompatible types in assignment (expression has type "X", variable has type Mapping[str, C])
+m2: Mapping[str, C] = x # E: Incompatible types in assignment (expression has type "X", variable has type "Mapping[str, C]")
 [builtins fixtures/dict.pyi]
 
 [case testForwardReferenceInClassTypedDict]
@@ -1298,7 +1298,7 @@ class C(B): pass
 x: X
 reveal_type(x) # E: Revealed type is 'TypedDict('__main__.X', {'b': __main__.B, 'c': __main__.C})'
 m1: Mapping[str, B] = x
-m2: Mapping[str, C] = x # E: Incompatible types in assignment (expression has type "X", variable has type Mapping[str, C])
+m2: Mapping[str, C] = x # E: Incompatible types in assignment (expression has type "X", variable has type "Mapping[str, C]")
 [builtins fixtures/dict.pyi]
 
 [case testForwardReferenceToTypedDictInTypedDict]
diff --git a/test-data/unit/check-typevar-values.test b/test-data/unit/check-typevar-values.test
--- a/test-data/unit/check-typevar-values.test
+++ b/test-data/unit/check-typevar-values.test
@@ -270,7 +270,7 @@ y = C(S())
 x = y
 y = x
 c_int = C(1) # type: C[int]
-y = c_int # E: Incompatible types in assignment (expression has type C[int], variable has type C[str])
+y = c_int # E: Incompatible types in assignment (expression has type "C[int]", variable has type "C[str]")
 
 [case testGenericTypeBodyWithTypevarValues]
 from typing import TypeVar, Generic
@@ -524,7 +524,7 @@ a = f
 a = g
 b = g
 b = g
-b = f # E: Incompatible types in assignment (expression has type Callable[[T], T], variable has type Callable[[U], U])
+b = f # E: Incompatible types in assignment (expression has type "Callable[[T], T]", variable has type "Callable[[U], U]")
 
 [case testInnerFunctionWithTypevarValues]
 from typing import TypeVar
diff --git a/test-data/unit/check-unreachable-code.test b/test-data/unit/check-unreachable-code.test
--- a/test-data/unit/check-unreachable-code.test
+++ b/test-data/unit/check-unreachable-code.test
@@ -84,7 +84,7 @@ main:6: note: (Perhaps setting MYPYPATH or using the "--ignore-missing-imports"
 import typing
 MYPY = 0
 if MYPY:
-    None + 1 # E: Unsupported left operand type for + (None)
+    None + 1 # E: Unsupported left operand type for + ("None")
 else:
     None + ''
 [builtins fixtures/bool.pyi]
diff --git a/test-data/unit/check-varargs.test b/test-data/unit/check-varargs.test
--- a/test-data/unit/check-varargs.test
+++ b/test-data/unit/check-varargs.test
@@ -10,8 +10,8 @@ from typing import Tuple
 def f( *b: 'B') -> None:
     ab = None # type: Tuple[B, ...]
     ac = None # type: Tuple[C, ...]
-    b = ac # E: Incompatible types in assignment (expression has type Tuple[C, ...], variable has type Tuple[B, ...])
-    ac = b # E: Incompatible types in assignment (expression has type Tuple[B, ...], variable has type Tuple[C, ...])
+    b = ac # E: Incompatible types in assignment (expression has type "Tuple[C, ...]", variable has type "Tuple[B, ...]")
+    ac = b # E: Incompatible types in assignment (expression has type "Tuple[B, ...]", variable has type "Tuple[C, ...]")
     b = ab
     ab = b
 
@@ -108,7 +108,7 @@ it1 = None  # type: Iterable[int]
 it2 = None  # type: Iterable[str]
 def f(*x: int) -> None: pass
 f(*it1)
-f(*it2) # E: Argument 1 to "f" has incompatible type *Iterable[str]; expected "int"
+f(*it2) # E: Argument 1 to "f" has incompatible type "*Iterable[str]"; expected "int"
 [builtins fixtures/for.pyi]
 
 [case testCallVarargsFunctionWithIterableAndPositional]
@@ -208,7 +208,7 @@ class A: pass
 class B: pass
 [builtins fixtures/list.pyi]
 [out]
-main:7: error: Argument 1 to "f" has incompatible type *List[A]; expected "B"
+main:7: error: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
 
 [case testCallingWithTupleVarArgs]
 
@@ -217,9 +217,9 @@ b = None # type: B
 c = None # type: C
 cc = None # type: CC
 
-f(*(a, b, b)) # E: Argument 1 to "f" has incompatible type *"Tuple[A, B, B]"; expected "C"
-f(*(b, b, c)) # E: Argument 1 to "f" has incompatible type *"Tuple[B, B, C]"; expected "A"
-f(a, *(b, b)) # E: Argument 2 to "f" has incompatible type *"Tuple[B, B]"; expected "C"
+f(*(a, b, b)) # E: Argument 1 to "f" has incompatible type "*Tuple[A, B, B]"; expected "C"
+f(*(b, b, c)) # E: Argument 1 to "f" has incompatible type "*Tuple[B, B, C]"; expected "A"
+f(a, *(b, b)) # E: Argument 2 to "f" has incompatible type "*Tuple[B, B]"; expected "C"
 f(b, *(b, c)) # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 f(*(a, b))    # E: Too few arguments for "f"
 f(*(a, b, c, c)) # E: Too many arguments for "f"
@@ -277,26 +277,26 @@ class A: pass
 class B: pass
 [builtins fixtures/list.pyi]
 [out]
-main:3: error: Argument 1 to "f" has incompatible type *List[A]; expected "B"
-main:4: error: Argument 2 to "f" has incompatible type *List[A]; expected "B"
+main:3: error: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
+main:4: error: Argument 2 to "f" has incompatible type "*List[A]"; expected "B"
 main:5: error: Argument 1 to "f" has incompatible type "B"; expected "A"
 main:6: error: Argument 2 to "f" has incompatible type "A"; expected "B"
-main:7: error: Argument 3 to "f" has incompatible type *List[A]; expected "B"
+main:7: error: Argument 3 to "f" has incompatible type "*List[A]"; expected "B"
 main:8: error: Argument 1 to "f" has incompatible type "B"; expected "A"
-main:9: error: Argument 1 to "g" has incompatible type *List[B]; expected "A"
+main:9: error: Argument 1 to "g" has incompatible type "*List[B]"; expected "A"
 
 [case testCallingVarArgsFunctionWithTupleVarArgs]
 
 a, b, c, cc = None, None, None, None # type: (A, B, C, CC)
 
-f(*(b, b, b))   # E: Argument 1 to "f" has incompatible type *"Tuple[B, B, B]"; expected "A"
-f(*(a, a, b))   # E: Argument 1 to "f" has incompatible type *"Tuple[A, A, B]"; expected "B"
-f(*(a, b, a))   # E: Argument 1 to "f" has incompatible type *"Tuple[A, B, A]"; expected "B"
-f(a, *(a, b))   # E: Argument 2 to "f" has incompatible type *"Tuple[A, B]"; expected "B"
+f(*(b, b, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[B, B, B]"; expected "A"
+f(*(a, a, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, A, B]"; expected "B"
+f(*(a, b, a))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, B, A]"; expected "B"
+f(a, *(a, b))   # E: Argument 2 to "f" has incompatible type "*Tuple[A, B]"; expected "B"
 f(b, *(b, b))   # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 f(b, b, *(b,))  # E: Argument 1 to "f" has incompatible type "B"; expected "A"
 f(a, a, *(b,))  # E: Argument 2 to "f" has incompatible type "A"; expected "B"
-f(a, b, *(a,))  # E: Argument 3 to "f" has incompatible type *"Tuple[A]"; expected "B"
+f(a, b, *(a,))  # E: Argument 3 to "f" has incompatible type "*Tuple[A]"; expected "B"
 f(*())          # E: Too few arguments for "f"
 f(*(a, b, b))
 f(a, *(b, b))
@@ -340,7 +340,7 @@ from typing import List
 aa = None # type: List[A]
 ab = None # type: List[B]
 
-g(*aa) # E: Argument 1 to "g" has incompatible type *List[A]; expected "B"
+g(*aa) # E: Argument 1 to "g" has incompatible type "*List[A]"; expected "B"
 f(*aa)
 f(*ab)
 g(*ab)
@@ -377,10 +377,10 @@ class B: pass
 [builtins fixtures/list.pyi]
 [out]
 main:3: error: Too few arguments for "f"
-main:4: error: Argument 2 to "f" has incompatible type *List[A]; expected "Optional[B]"
-main:4: error: Argument 2 to "f" has incompatible type *List[A]; expected "B"
-main:5: error: Argument 3 to "f" has incompatible type *List[A]; expected "B"
-main:6: error: Argument 1 to "f" has incompatible type *"Tuple[A, A, B]"; expected "Optional[B]"
+main:4: error: Argument 2 to "f" has incompatible type "*List[A]"; expected "Optional[B]"
+main:4: error: Argument 2 to "f" has incompatible type "*List[A]"; expected "B"
+main:5: error: Argument 3 to "f" has incompatible type "*List[A]"; expected "B"
+main:6: error: Argument 1 to "f" has incompatible type "*Tuple[A, A, B]"; expected "Optional[B]"
 
 [case testVarArgsAfterKeywordArgInCall1-skip]
 # see: mypy issue #2729
@@ -492,11 +492,11 @@ class A: pass
 class B: pass
 [builtins fixtures/list.pyi]
 [out]
-main:6: error: Argument 1 to "f" has incompatible type *List[A]; expected "B"
-main:7: error: Argument 1 to "f" has incompatible type *List[A]; expected "B"
+main:6: error: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
+main:7: error: Argument 1 to "f" has incompatible type "*List[A]"; expected "B"
 main:8: error: Argument 1 to "f" has incompatible type "B"; expected "A"
-main:9: error: Argument 2 to "f" has incompatible type *List[A]; expected "B"
-main:10: error: Argument 3 to "f" has incompatible type *List[A]; expected "B"
+main:9: error: Argument 2 to "f" has incompatible type "*List[A]"; expected "B"
+main:10: error: Argument 3 to "f" has incompatible type "*List[A]"; expected "B"
 main:11: error: List or tuple expected as variable arguments
 main:12: error: List or tuple expected as variable arguments
 
@@ -506,9 +506,9 @@ S = TypeVar('S')
 T = TypeVar('T')
 a, b = None, None # type: (A, B)
 
-a, a = f(*(a, b))   # E: Argument 1 to "f" has incompatible type *"Tuple[A, B]"; expected "A"
+a, a = f(*(a, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, B]"; expected "A"
 b, b = f(a, *(b,))  # E: Argument 1 to "f" has incompatible type "A"; expected "B"
-a, a = f(*(a, b))   # E: Argument 1 to "f" has incompatible type *"Tuple[A, B]"; expected "A"
+a, a = f(*(a, b))   # E: Argument 1 to "f" has incompatible type "*Tuple[A, B]"; expected "A"
 b, b = f(a, *(b,))  # E: Argument 1 to "f" has incompatible type "A"; expected "B"
 a, b = f(*(a, b, b)) # E: Too many arguments for "f"
 
@@ -534,8 +534,8 @@ a, aa = G().f(*[a])  # Fail
 aa, a = G().f(*[a])  # Fail
 ab, aa = G().f(*[a]) # Fail
 
-ao, ao = G().f(*[a]) # E: Incompatible types in assignment (expression has type List[<nothing>], variable has type List[object])
-aa, aa = G().f(*[a]) # E: Incompatible types in assignment (expression has type List[<nothing>], variable has type List[A])
+ao, ao = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[object]")
+aa, aa = G().f(*[a]) # E: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]")
 
 class G(Generic[T]):
     def f(self, *a: S) -> Tuple[List[S], List[T]]:
@@ -545,11 +545,11 @@ class A: pass
 class B: pass
 [builtins fixtures/list.pyi]
 [out]
-main:9: error: Incompatible types in assignment (expression has type List[A], variable has type "A")
-main:9: error: Incompatible types in assignment (expression has type List[<nothing>], variable has type List[A])
-main:10: error: Incompatible types in assignment (expression has type List[<nothing>], variable has type "A")
-main:11: error: Incompatible types in assignment (expression has type List[<nothing>], variable has type List[A])
-main:11: error: Argument 1 to "f" of "G" has incompatible type *List[A]; expected "B"
+main:9: error: Incompatible types in assignment (expression has type "List[A]", variable has type "A")
+main:9: error: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]")
+main:10: error: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "A")
+main:11: error: Incompatible types in assignment (expression has type "List[<nothing>]", variable has type "List[A]")
+main:11: error: Argument 1 to "f" of "G" has incompatible type "*List[A]"; expected "B"
 
 
 -- Comment signatures
@@ -577,7 +577,7 @@ x = None # type: Callable[[int], None]
 def f(*x: int) -> None: pass
 def g(*x: str) -> None: pass
 x = f
-x = g # E: Incompatible types in assignment (expression has type Callable[[VarArg(str)], None], variable has type Callable[[int], None])
+x = g # E: Incompatible types in assignment (expression has type "Callable[[VarArg(str)], None]", variable has type "Callable[[int], None]")
 [builtins fixtures/list.pyi]
 [out]
 
@@ -603,15 +603,15 @@ a = {'a': [1, 2]}
 b = {'b': ['c', 'd']}
 c = {'c': 1.0}
 d = {'d': 1}
-f(a) # E: Argument 1 to "f" has incompatible type Dict[str, List[int]]; expected Dict[str, Sequence[int]] \
+f(a) # E: Argument 1 to "f" has incompatible type "Dict[str, List[int]]"; expected "Dict[str, Sequence[int]]" \
      # N: "Dict" is invariant -- see http://mypy.readthedocs.io/en/latest/common_issues.html#variance \
      # N: Consider using "Mapping" instead, which is covariant in the value type
-f(b) # E: Argument 1 to "f" has incompatible type Dict[str, List[str]]; expected Dict[str, Sequence[int]]
+f(b) # E: Argument 1 to "f" has incompatible type "Dict[str, List[str]]"; expected "Dict[str, Sequence[int]]"
 g(c)
-g(d) # E: Argument 1 to "g" has incompatible type Dict[str, int]; expected Dict[str, float] \
+g(d) # E: Argument 1 to "g" has incompatible type "Dict[str, int]"; expected "Dict[str, float]" \
      # N: "Dict" is invariant -- see http://mypy.readthedocs.io/en/latest/common_issues.html#variance \
      # N: Consider using "Mapping" instead, which is covariant in the value type
-h(c) # E: Argument 1 to "h" has incompatible type Dict[str, float]; expected Dict[str, int]
+h(c) # E: Argument 1 to "h" has incompatible type "Dict[str, float]"; expected "Dict[str, int]"
 h(d)
 [builtins fixtures/dict.pyi]
 
@@ -619,12 +619,12 @@ h(d)
 from typing import List, Union
 def f(numbers: List[Union[int, float]]) -> None: pass
 a = [1, 2]
-f(a) # E: Argument 1 to "f" has incompatible type List[int]; expected List[Union[int, float]] \
+f(a) # E: Argument 1 to "f" has incompatible type "List[int]"; expected "List[Union[int, float]]" \
      # N: "List" is invariant -- see http://mypy.readthedocs.io/en/latest/common_issues.html#variance \
      # N: Consider using "Sequence" instead, which is covariant
 x = [1]
 y = ['a']
-x = y # E: Incompatible types in assignment (expression has type List[str], variable has type List[int])
+x = y # E: Incompatible types in assignment (expression has type "List[str]", variable has type "List[int]")
 [builtins fixtures/list.pyi]
 
 [case testInvariantTypeConfusingNames]
@@ -635,6 +635,6 @@ def f(x: Listener) -> None: pass
 def g(y: DictReader) -> None: pass
 a = [1, 2]
 b = {'b': 1}
-f(a) # E: Argument 1 to "f" has incompatible type List[int]; expected "Listener"
-g(b) # E: Argument 1 to "g" has incompatible type Dict[str, int]; expected "DictReader"
+f(a) # E: Argument 1 to "f" has incompatible type "List[int]"; expected "Listener"
+g(b) # E: Argument 1 to "g" has incompatible type "Dict[str, int]"; expected "DictReader"
 [builtins fixtures/dict.pyi]
diff --git a/test-data/unit/pythoneval-asyncio.test b/test-data/unit/pythoneval-asyncio.test
--- a/test-data/unit/pythoneval-asyncio.test
+++ b/test-data/unit/pythoneval-asyncio.test
@@ -339,7 +339,7 @@ loop.run_until_complete(future)
 print(future.result())
 loop.close()
 [out]
-_program.py:12: error: Argument 1 to "slow_operation" has incompatible type Future[str]; expected Future[int]
+_program.py:12: error: Argument 1 to "slow_operation" has incompatible type "Future[str]"; expected "Future[int]"
 
 [case testErrorUsingDifferentFutureTypeAndSetFutureDifferentInternalType]
 from typing import Generator, Any
@@ -359,7 +359,7 @@ print(future.result())
 loop.close()
 [out]
 _program.py:8: error: Argument 1 to "set_result" of "Future" has incompatible type "str"; expected "int"
-_program.py:12: error: Argument 1 to "slow_operation" has incompatible type Future[str]; expected Future[int]
+_program.py:12: error: Argument 1 to "slow_operation" has incompatible type "Future[str]"; expected "Future[int]"
 
 [case testErrorSettingCallbackWithDifferentFutureType]
 import typing
@@ -386,7 +386,7 @@ try:
 finally:
     loop.close()
 [out]
-_program.py:18: error: Argument 1 to "add_done_callback" of "Future" has incompatible type Callable[[Future[int]], None]; expected Callable[[Future[str]], Any]
+_program.py:18: error: Argument 1 to "add_done_callback" of "Future" has incompatible type "Callable[[Future[int]], None]"; expected "Callable[[Future[str]], Any]"
 
 [case testErrorOneMoreFutureInReturnType]
 import typing
@@ -422,7 +422,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(h())
 loop.close()
 [out]
-_program.py:18: error: Incompatible return value type (got Future[Future[int]], expected Future[Future[Future[int]]])
+_program.py:18: error: Incompatible return value type (got "Future[Future[int]]", expected "Future[Future[Future[int]]]")
 
 [case testErrorOneLessFutureInReturnType]
 import typing
@@ -456,7 +456,7 @@ loop = asyncio.get_event_loop()
 loop.run_until_complete(h())
 loop.close()
 [out]
-_program.py:18: error: Incompatible return value type (got Future[Future[int]], expected Future[int])
+_program.py:18: error: Incompatible return value type (got "Future[Future[int]]", expected "Future[int]")
 
 [case testErrorAssignmentDifferentType]
 import typing
diff --git a/test-data/unit/pythoneval.test b/test-data/unit/pythoneval.test
--- a/test-data/unit/pythoneval.test
+++ b/test-data/unit/pythoneval.test
@@ -391,7 +391,7 @@ txt(sys.stdout)
 bin(sys.stdout)
 [out]
 _program.py:5: error: Argument 1 to "write" of "IO" has incompatible type "bytes"; expected "str"
-_program.py:10: error: Argument 1 to "bin" has incompatible type "TextIO"; expected IO[bytes]
+_program.py:10: error: Argument 1 to "bin" has incompatible type "TextIO"; expected "IO[bytes]"
 
 [case testBuiltinOpen]
 f = open('x')
@@ -603,7 +603,7 @@ print(tuple(a))
 import typing
 [1] + iter([2, 3])
 [out]
-_program.py:2: error: Unsupported operand types for + (List[int] and Iterator[int])
+_program.py:2: error: Unsupported operand types for + ("List[int]" and "Iterator[int]")
 
 [case testInferHeterogeneousListOfIterables]
 from typing import Sequence
@@ -784,7 +784,7 @@ def f(*args: str) -> str: return args[0]
 map(f, ['x'])
 map(f, [1])
 [out]
-_program.py:4: error: Argument 1 to "map" has incompatible type Callable[[VarArg(str)], str]; expected Callable[[int], str]
+_program.py:4: error: Argument 1 to "map" has incompatible type "Callable[[VarArg(str)], str]"; expected "Callable[[int], str]"
 
 [case testMapStr]
 import typing
@@ -792,7 +792,7 @@ x = range(3)
 a = list(map(str, x))
 a + 1
 [out]
-_program.py:4: error: Unsupported operand types for + (List[str] and "int")
+_program.py:4: error: Unsupported operand types for + ("List[str]" and "int")
 
 [case testNamedTuple]
 import typing
@@ -994,7 +994,7 @@ def f(*x: int) -> None:
     x.append(1)
 f(1)
 [out]
-_program.py:3: error: Tuple[int, ...] has no attribute "append"
+_program.py:3: error: "Tuple[int, ...]" has no attribute "append"
 
 [case testExit]
 print('a')
@@ -1075,14 +1075,14 @@ n = 4
 t = ('',) * n
 t + 1
 [out]
-_program.py:3: error: Unsupported operand types for + (Tuple[str, ...] and "int")
+_program.py:3: error: Unsupported operand types for + ("Tuple[str, ...]" and "int")
 
 [case testMultiplyTupleByIntegerReverse]
 n = 4
 t = n * ('',)
 t + 1
 [out]
-_program.py:3: error: Unsupported operand types for + (Tuple[str, ...] and "int")
+_program.py:3: error: Unsupported operand types for + ("Tuple[str, ...]" and "int")
 
 [case testDictWithKeywordArgs]
 from typing import Dict, Any, List
@@ -1094,7 +1094,7 @@ d4 = dict(a=1, b='') # type: Dict[str, Any]
 result = dict(x=[], y=[]) # type: Dict[str, List[str]]
 [out]
 _program.py:3: error: Dict entry 1 has incompatible type "str": "str"; expected "str": "int"
-_program.py:5: error: Dict[str, int] has no attribute "xyz"
+_program.py:5: error: "Dict[str, int]" has no attribute "xyz"
 
 [case testDefaultDict]
 import typing as t
@@ -1122,11 +1122,11 @@ class MyDDict(t.DefaultDict[int,T], t.Generic[T]):
 MyDDict(dict)['0']
 MyDDict(dict)[0]
 [out]
-_program.py:6: error: Argument 1 to "defaultdict" has incompatible type Type[List[Any]]; expected Callable[[], str]
-_program.py:9: error: Invalid index type "str" for defaultdict[int, str]; expected type "int"
+_program.py:6: error: Argument 1 to "defaultdict" has incompatible type "Type[List[Any]]"; expected "Callable[[], str]"
+_program.py:9: error: Invalid index type "str" for "defaultdict[int, str]"; expected type "int"
 _program.py:9: error: Incompatible types in assignment (expression has type "int", target has type "str")
-_program.py:19: error: Dict entry 0 has incompatible type "str": List[<nothing>]; expected "int": List[<nothing>]
-_program.py:23: error: Invalid index type "str" for MyDDict[Dict[_KT, _VT]]; expected type "int"
+_program.py:19: error: Dict entry 0 has incompatible type "str": "List[<nothing>]"; expected "int": "List[<nothing>]"
+_program.py:23: error: Invalid index type "str" for "MyDDict[Dict[_KT, _VT]]"; expected type "int"
 
 [case testNoSubcriptionOfStdlibCollections]
 import collections
@@ -1148,7 +1148,7 @@ def f(d: collections.defaultdict[int, str]) -> None:
 _program.py:5: error: "defaultdict" is not subscriptable
 _program.py:6: error: "Counter" is not subscriptable
 _program.py:9: error: "defaultdict" is not subscriptable
-_program.py:12: error: Invalid index type "int" for defaultdict[str, int]; expected type "str"
+_program.py:12: error: Invalid index type "int" for "defaultdict[str, int]"; expected type "str"
 _program.py:14: error: "defaultdict" is not subscriptable, use "typing.DefaultDict" instead
 
 [case testCollectionsAliases]
@@ -1176,7 +1176,7 @@ reveal_type(o6)
 
 [out]
 _testCollectionsAliases.py:5: error: Revealed type is 'collections.Counter[builtins.int]'
-_testCollectionsAliases.py:6: error: Invalid index type "str" for Counter[int]; expected type "int"
+_testCollectionsAliases.py:6: error: Invalid index type "str" for "Counter[int]"; expected type "int"
 _testCollectionsAliases.py:9: error: Revealed type is 'collections.ChainMap[builtins.int, builtins.str]'
 _testCollectionsAliases.py:12: error: Revealed type is 'collections.deque[builtins.int]'
 _testCollectionsAliases.py:15: error: Revealed type is 'collections.Counter[builtins.int*]'
@@ -1393,4 +1393,4 @@ c: Container[str] = p
 o: object = p
 it2: Iterable[int] = p
 [out]
-_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: error: Incompatible types in assignment (expression has type "Point", variable has type Iterable[int])
+_testCanConvertTypedDictToAnySuperclassOfMapping.py:11: error: Incompatible types in assignment (expression has type "Point", variable has type "Iterable[int]")