[Sema][C++] Propagate conversion type in order to specialize the diagnostics

[Anastasia]

Summary

Currently in C++ we don't set/propagate what type of implicit conversions occurs on assignments/initializations/params/etc. Therefore the diagnostic provided is more generic than in C mode. This patch attempt to propagate the conversion kind through layers of C++ semantic checks. It is currently only used for address spaces conversion of nested pointers (from https://reviews.llvm.org/D73360). Setting this for other conversions would be quite a lot of work and I am not sure I feel confident to get it right. We could potentially gradually modify it as we go along. Although this is not an actively modified code base at the moment so not sure whether it will happen and when.

Feedback welcome!

[rjmccall]

Hmm. The alternative approach, I suppose, would be to recognize that we're about to emit a generic error and just recheck assignment constraints to recompute the AssignConvertType.

[Anastasia]

In D74116#1863186, @rjmccall wrote:

Hmm. The alternative approach, I suppose, would be to recognize that we're about to emit a generic error and just recheck assignment constraints to recompute the AssignConvertType.

Indeed. It will need less changes around the code base but also means checks will be repeated.

[rjmccall]

This shouldn't be an expensive function call, and being a little inefficient on the error path to get better diagnostics is a good trade-off.

[Anastasia]

If I reuse the helper checkPointerTypesForAssignment I end up with lots of error turned into warnings, see example in
test/SemaCXX/addr-of-overloaded-function.cpp

I guess we don't want them to be warnings? Should we duplicate all those as errors in C++?

It seems there are about 3 of them that would have to be duplicated:

[40/41] Running the Clang regression tests
llvm-lit: ...llvm/utils/lit/lit/llvm/config.py:342: note: using clang: ...build/bin/clang
FAIL: Clang :: CXX/conv/conv.fctptr/p1.cpp (1051 of 16808)
******************** TEST 'Clang :: CXX/conv/conv.fctptr/p1.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -std=c++1z -verify ...clang/test/CXX/conv/conv.fctptr/p1.cpp -triple x86_64-unknown-unknown
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/CXX/conv/conv.fctptr/p1.cpp Line 14: assigning to 'Nothrow *' (aka 'void (*)() noexcept') from incompatible type 'Throw *' (aka 'void (*)()'): different exception specifications
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/CXX/conv/conv.fctptr/p1.cpp Line 14: incompatible function pointer types assigning to 'Nothrow *' (aka 'void (*)() noexcept') from 'Throw *' (aka 'void (*)()')
2 errors generated.

--

********************
FAIL: Clang :: CXX/except/except.handle/p16.cpp (1234 of 16808)
******************** TEST 'Clang :: CXX/except/except.handle/p16.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fcxx-exceptions -fexceptions -fsyntax-only -verify ...clang/test/CXX/except/except.handle/p16.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/CXX/except/except.handle/p16.cpp Line 14: assigning to 'float *' from incompatible type 'int *'
  File ...clang/test/CXX/except/except.handle/p16.cpp Line 19: assigning to 'int *' from incompatible type 'float *'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/CXX/except/except.handle/p16.cpp Line 14: incompatible pointer types assigning to 'float *' from 'int *'
  File ...clang/test/CXX/except/except.handle/p16.cpp Line 19: incompatible pointer types assigning to 'int *' from 'float *'
4 errors generated.

--

********************
FAIL: Clang :: CXX/expr/p13.cpp (1350 of 16808)
******************** TEST 'Clang :: CXX/expr/p13.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -std=c++1z -verify ...clang/test/CXX/expr/p13.cpp -fexceptions -fcxx-exceptions -Wno-dynamic-exception-spec
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/CXX/expr/p13.cpp Line 14: different exception specifications
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/CXX/expr/p13.cpp Line 14: incompatible function pointer types assigning to 'A' (aka 'void (*)() noexcept') from 'void (*)()'
2 errors generated.

--

********************
FAIL: Clang :: CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp (1519 of 16808)
******************** TEST 'Clang :: CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify ...clang/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp Line 13: incompatible
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/CXX/temp/temp.decls/temp.class/temp.mem.class/p1.cpp Line 13: incompatible pointer types assigning to 'int *' from 'float *'
2 errors generated.

--

********************
FAIL: Clang :: SemaCXX/addr-of-overloaded-function.cpp (9959 of 16808)
******************** TEST 'Clang :: SemaCXX/addr-of-overloaded-function.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify ...clang/test/SemaCXX/addr-of-overloaded-function.cpp
: 'RUN: at line 2';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++98 ...clang/test/SemaCXX/addr-of-overloaded-function.cpp
: 'RUN: at line 3';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++11 ...clang/test/SemaCXX/addr-of-overloaded-function.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File ...clang/test/SemaCXX/addr-of-overloaded-function.cpp Line 191: incompatible function pointer types assigning to 'void (*)(int, int)' from 'void (*)(int)'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaCXX/addr-of-overloaded-function.cpp Line 191: incompatible function pointer types assigning to 'void (*)(double)' from 'void (*)(int)'
2 errors generated.

--

********************
FAIL: Clang :: SemaObjCXX/noescape.mm (11344 of 16808)
******************** TEST 'Clang :: SemaObjCXX/noescape.mm' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -fblocks -std=c++11 ...clang/test/SemaObjCXX/noescape.mm
: 'RUN: at line 2';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -fblocks -std=c++1z ...clang/test/SemaObjCXX/noescape.mm
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaObjCXX/noescape.mm Line 77: assigning to 'void (*)(__attribute__((noescape)) int *)' from incompatible type 'void (*)(int *)'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaObjCXX/noescape.mm Line 77: incompatible function pointer types assigning to 'void (*)(__attribute__((noescape)) int *)' from 'void (*)(int *)'
2 errors generated.

--

********************
FAIL: Clang :: SemaObjCXX/nullability-pragmas.mm (11349 of 16808)
******************** TEST 'Clang :: SemaObjCXX/nullability-pragmas.mm' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -fblocks -I ...clang/test/SemaObjCXX/Inputs ...clang/test/SemaObjCXX/nullability-pragmas.mm -verify
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 35: assigning to 'float *' from incompatible type 'int_ptr _Nonnull' (aka 'int *')
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 39: assigning to 'float *' from incompatible type 'int * _Nonnull'
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 40: assigning to 'float *' from incompatible type 'int * _Null_unspecified'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 35: incompatible pointer types assigning to 'float *' from 'int_ptr _Nonnull' (aka 'int *')
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 39: incompatible pointer types assigning to 'float *' from 'int * _Nonnull'
  File ...clang/test/SemaObjCXX/nullability-pragmas.mm Line 40: incompatible pointer types assigning to 'float *' from 'int * _Null_unspecified'
6 errors generated.

--

********************
FAIL: Clang :: SemaObjCXX/parameterized_classes_subst.mm (11380 of 16808)
******************** TEST 'Clang :: SemaObjCXX/parameterized_classes_subst.mm' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fblocks -fsyntax-only -std=c++11 ...clang/test/SemaObjCXX/parameterized_classes_subst.mm -verify
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 252: from incompatible type 'NSString **'
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 253: from incompatible type 'id *'
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 260: from incompatible type 'Window **'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 252: incompatible pointer types assigning to 'int *' from 'NSString **'
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 253: incompatible pointer types assigning to 'int *' from 'id *'
  File ...clang/test/SemaObjCXX/parameterized_classes_subst.mm Line 260: incompatible pointer types assigning to 'int *' from 'Window **'
6 errors generated.

--

********************
FAIL: Clang :: SemaTemplate/instantiate-declref.cpp (11592 of 16808)
******************** TEST 'Clang :: SemaTemplate/instantiate-declref.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify ...clang/test/SemaTemplate/instantiate-declref.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaTemplate/instantiate-declref.cpp Line 53: incompatible
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaTemplate/instantiate-declref.cpp Line 53: incompatible pointer types assigning to 'int *' from 'float *'
2 errors generated.

--

********************
FAIL: Clang :: SemaTemplate/instantiate-member-class.cpp (11611 of 16808)
******************** TEST 'Clang :: SemaTemplate/instantiate-member-class.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify ...clang/test/SemaTemplate/instantiate-member-class.cpp
: 'RUN: at line 2';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++98 ...clang/test/SemaTemplate/instantiate-member-class.cpp
: 'RUN: at line 3';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++11 ...clang/test/SemaTemplate/instantiate-member-class.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaTemplate/instantiate-member-class.cpp Line 46: assigning to 'X<int>::C *' from incompatible type 'X<float>::C *'
  File ...clang/test/SemaTemplate/instantiate-member-class.cpp Line 47: assigning to 'X<int>::X<int> *' from incompatible type 'X<float>::X<float> *'
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaTemplate/instantiate-member-class.cpp Line 46: incompatible pointer types assigning to 'X<int>::C *' from 'X<float>::C *'
  File ...clang/test/SemaTemplate/instantiate-member-class.cpp Line 47: incompatible pointer types assigning to 'X<int>::X<int> *' from 'X<float>::X<float> *'
4 errors generated.

--

********************
FAIL: Clang :: SemaTemplate/member-access-expr.cpp (11657 of 16808)
******************** TEST 'Clang :: SemaTemplate/member-access-expr.cpp' FAILED ********************
Script:
--
: 'RUN: at line 1';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify ...clang/test/SemaTemplate/member-access-expr.cpp
: 'RUN: at line 2';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++98 ...clang/test/SemaTemplate/member-access-expr.cpp
: 'RUN: at line 3';   ...build/bin/clang -cc1 -internal-isystem ...build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -std=c++11 ...clang/test/SemaTemplate/member-access-expr.cpp
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File ...clang/test/SemaTemplate/member-access-expr.cpp Line 159: assigning to 'test6::B *' from incompatible type 'test6::A *
error: 'warning' diagnostics seen but not expected: 
  File ...clang/test/SemaTemplate/member-access-expr.cpp Line 159: incompatible pointer types assigning to 'test6::B *' from 'test6::A *'
2 errors generated.

Also I guess checkPointerTypesForAssignment should be changed so that it works for references too...

[rjmccall]

Ah, yes, we're laxer about these things in C than we are in C++. If we do this, we'll need to go through DiagnoseAssignmentResult and make sure that everything (except Compatible, which we'll never pass) triggers an error in C++ mode.

Is there a good reason to just do this for pointer types instead of unconditionally calling CheckAssignmentConstraints? It'd be nice to take advantage of any specialized diagnostics we have for C/ObjC/whatever in C++ mode, and that can apply to a lot of types that aren't pointer types.

It looks like there's already some type analysis in DiagnoseAssignmentResult to get a specialized diagnostic for certain cases of function-pointer assignment. That could probably be easily moved into CheckAssignmentConstraints by just adding a few more cases to AssignConvertResult.

And yeah, it's possible that we'll need to teach that function about some C++ cases that it currently never sees. But I don't think that needs to include references, because IIRC reference-binding doesn't go through ImplicitConversionSequence.

[Anastasia]

• Switched to using CheckAssignmentConstraints
• Duplicated all extensions and warnings as errors for C++ mode
• Added IncompatibleFunctionPointer

[Anastasia]

It looks like there's already some type analysis in DiagnoseAssignmentResult to get a specialized diagnostic for certain cases of function-pointer assignment. That could probably be easily moved into CheckAssignmentConstraints by just adding a few more cases to AssignConvertResult.

One interesting effect I get after modifying this that some extra tests in C mode started to report function pointer instead of generic pointer warning. I feel this is because in checkPointerTypesForAssignment we use canonical types and in DiagnoseAssignmentResult we don't.

Perhaps this way is better? I can update the test if so and then finalize some other bits.

FAIL: Clang :: Sema/block-return.c (9341 of 16808)
******************** TEST 'Clang :: Sema/block-return.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -Wno-int-to-pointer-cast -pedantic -fsyntax-only <...>clang/test/Sema/block-return.c -verify -fblocks
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/block-return.c Line 82: incompatible pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/block-return.c Line 82: incompatible function pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'
2 errors generated.

--

********************
FAIL: Clang :: Sema/callingconv-ms_abi.c (9396 of 16808)
******************** TEST 'Clang :: Sema/callingconv-ms_abi.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -triple x86_64-pc-win32 <...>clang/test/Sema/callingconv-ms_abi.c
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/callingconv-ms_abi.c Line 7: incompatible pointer types
  File <...>clang/test/Sema/callingconv-ms_abi.c Line 9: incompatible pointer types
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/callingconv-ms_abi.c Line 7: incompatible function pointer types initializing 'void (*)(void)' with an expression of type 'void (void) __attribute__((sysv_abi))'
  File <...>clang/test/Sema/callingconv-ms_abi.c Line 9: incompatible function pointer types initializing 'void (*)(void) __attribute__((sysv_abi))' with an expression of type 'void (void) __attribute__((ms_abi))'
4 errors generated.

--

********************
FAIL: Clang :: Sema/callingconv-sysv_abi.c (9397 of 16808)
******************** TEST 'Clang :: Sema/callingconv-sysv_abi.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -triple x86_64-pc-linux-gnu <...>clang/test/Sema/callingconv-sysv_abi.c
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/callingconv-sysv_abi.c Line 4: incompatible pointer types
  File <...>clang/test/Sema/callingconv-sysv_abi.c Line 9: incompatible pointer types
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/callingconv-sysv_abi.c Line 4: incompatible function pointer types initializing 'void (*)(void)' with an expression of type 'void (void) __attribute__((ms_abi))'
  File <...>clang/test/Sema/callingconv-sysv_abi.c Line 9: incompatible function pointer types initializing 'void (*)(void) __attribute__((ms_abi))' with an expression of type 'void (void) __attribute__((sysv_abi))'
4 errors generated.

--

********************
FAIL: Clang :: Sema/callingconv.c (9398 of 16808)
******************** TEST 'Clang :: Sema/callingconv.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/callingconv.c -fsyntax-only -triple i386-unknown-unknown -verify
: 'RUN: at line 2';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/callingconv.c -fsyntax-only -triple i386-unknown-unknown -fms-compatibility -DWIN -verify
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/callingconv.c Line 34: incompatible pointer types
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/callingconv.c Line 34: incompatible function pointer types initializing 'void (*)(void) __attribute__((cdecl))' with an expression of type 'void (void) __attribute__((fastcall))'
2 errors generated.

--

********************
FAIL: Clang :: Sema/pass-object-size.c (9608 of 16808)
******************** TEST 'Clang :: Sema/pass-object-size.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify <...>clang/test/Sema/pass-object-size.c -triple x86_64-linux-gnu -Wincompatible-pointer-types
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/pass-object-size.c Line 47: incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
  File <...>clang/test/Sema/pass-object-size.c Line 48: incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/pass-object-size.c Line 47: incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
  File <...>clang/test/Sema/pass-object-size.c Line 48: incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
4 errors generated.

--

********************
FAIL: Clang :: Sema/overloadable.c (9609 of 16808)
******************** TEST 'Clang :: Sema/overloadable.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify <...>clang/test/Sema/overloadable.c -Wincompatible-pointer-types
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File <...>clang/test/Sema/overloadable.c Line 29: call to 'accept_funcptr' is ambiguous
error: 'error' diagnostics seen but not expected: 
  File <...>clang/test/Sema/overloadable.c Line 29: no matching function for call to 'accept_funcptr'
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/overloadable.c Line 122: incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
  File <...>clang/test/Sema/overloadable.c Line 123: incompatible pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/overloadable.c Line 122: incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'
  File <...>clang/test/Sema/overloadable.c Line 123: incompatible function pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'
6 errors generated.

--

********************
FAIL: Clang :: Sema/preserve-call-conv.c (9653 of 16808)
******************** TEST 'Clang :: Sema/preserve-call-conv.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/preserve-call-conv.c -fsyntax-only -triple x86_64-unknown-unknown -verify
: 'RUN: at line 2';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/preserve-call-conv.c -fsyntax-only -triple arm64-unknown-unknown -verify
: 'RUN: at line 3';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/preserve-call-conv.c -fsyntax-only -triple x86_64-unknown-windows-msvc -verify
: 'RUN: at line 4';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/preserve-call-conv.c -fsyntax-only -triple aarch64-unknown-windows-msvc -verify
: 'RUN: at line 5';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc <...>clang/test/Sema/preserve-call-conv.c -fsyntax-only -triple thumbv7-unknown-windows-msvc -verify
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/Sema/preserve-call-conv.c Line 17: incompatible pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_most))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 18: incompatible pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_most))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 33: incompatible pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_all))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 34: incompatible pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_all))'
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/Sema/preserve-call-conv.c Line 17: incompatible function pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_most))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 18: incompatible function pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_most))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 33: incompatible function pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_all))'
  File <...>clang/test/Sema/preserve-call-conv.c Line 34: incompatible function pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_all))'
8 errors generated.

--

********************
FAIL: Clang :: SemaObjC/comptypes-legal.m (10887 of 16808)
******************** TEST 'Clang :: SemaObjC/comptypes-legal.m' FAILED ********************
Script:
--
: 'RUN: at line 1';   <...>build/bin/clang -cc1 -internal-isystem <...>build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify -pedantic <...>clang/test/SemaObjC/comptypes-legal.m
--
Exit Code: 1

Command Output (stderr):
--
error: 'warning' diagnostics expected but not seen: 
  File <...>clang/test/SemaObjC/comptypes-legal.m Line 36: incompatible pointer types sending 'NSObject *(NSObject *, NSObject *)' to parameter of type 'FuncSignature *'
error: 'warning' diagnostics seen but not expected: 
  File <...>clang/test/SemaObjC/comptypes-legal.m Line 36: incompatible function pointer types sending 'NSObject *(NSObject *, NSObject *)' to parameter of type 'FuncSignature *' (aka 'id (*)(NSObject *, Derived *)')
2 errors generated.

--

********************

Testing Time: 438.97s
********************
Failing Tests (8):
    Clang :: Sema/block-return.c
    Clang :: Sema/callingconv-ms_abi.c
    Clang :: Sema/callingconv-sysv_abi.c
    Clang :: Sema/callingconv.c
    Clang :: Sema/overloadable.c
    Clang :: Sema/pass-object-size.c
    Clang :: Sema/preserve-call-conv.c
    Clang :: SemaObjC/comptypes-legal.m

[rjmccall]

The C diagnostic changes seem like improvements, yeah. The virtue of re-using the same infrastructure across language modes.

clang/lib/Sema/SemaExprCXX.cpp

3930

This assertion seems important; can we make it work?

[Anastasia]

clang/lib/Sema/SemaExprCXX.cpp

3930

Currently DiagnoseAssignmentResult returns true only for Incompatible , However we can change it to return true for all Incompatibel* in C++ mode. So yes it should be doable.

[rjmccall]

clang/lib/Sema/SemaExprCXX.cpp

3930

Okay. My guess is it should return true whenever we emit an error rather than a warning (ignoring the effects of things like -Werror, of course).

[Anastasia]

• Updated expected diagnostics for function pointer tests
• Make DiagnoseAsignmentResult return true for all incompatible cases in C++

[rjmccall]

clang/lib/Sema/SemaExpr.cpp

14834

Could you hoist this up to the place where we pick the diagnostic and then make it unconditional in the path that always selects an error?

That's a general comment: we should be setting isInvalid for all the places below where we select an error diagnostic.

[Anastasia]

clang/lib/Sema/SemaExpr.cpp

14834

That's a general comment: we should be setting isInvalid for all the places below where we select an error diagnostic.

If I change to set isInvalid for all error cases I get less diagnostics. I guess it's because we now stop earlier and don't continue to diagnosing in some cases.

FAIL: Clang :: Sema/block-call.c (9327 of 16808)
******************** TEST 'Clang :: Sema/block-call.c' FAILED ********************
Script:
--
: 'RUN: at line 1';   /data/llvm/llvm-forcommits/build/bin/clang -cc1 -internal-isystem /data/llvm/llvm-forcommits/build/lib/clang/11.0.0/include -nostdsysteminc -fsyntax-only -verify /data/llvm/llvm-forcommits/clang/test/Sema/block-call.c -fblocks
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File /data/llvm/llvm-forcommits/clang/test/Sema/block-call.c Line 36: invalid block pointer conversion assigning to 'int *(^)()' from 'int'
1 error generated.

--

********************
FAIL: Clang :: SemaObjC/arc.m (10804 of 16808)
******************** TEST 'Clang :: SemaObjC/arc.m' FAILED ********************
Script:
--
: 'RUN: at line 1';   /data/llvm/llvm-forcommits/build/bin/clang -cc1 -internal-isystem /data/llvm/llvm-forcommits/build/lib/clang/11.0.0/include -nostdsysteminc -triple x86_64-apple-darwin11 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -fblocks -verify -Wno-objc-root-class /data/llvm/llvm-forcommits/clang/test/SemaObjC/arc.m
: 'RUN: at line 2';   not /data/llvm/llvm-forcommits/build/bin/clang -cc1 -internal-isystem /data/llvm/llvm-forcommits/build/lib/clang/11.0.0/include -nostdsysteminc -triple x86_64-apple-darwin11 -fobjc-runtime-has-weak -fsyntax-only -fobjc-arc -fblocks -Wno-objc-root-class -fdiagnostics-parseable-fixits /data/llvm/llvm-forcommits/clang/test/SemaObjC/arc.m 2>&1
--
Exit Code: 1

Command Output (stderr):
--
error: 'error' diagnostics expected but not seen: 
  File /data/llvm/llvm-forcommits/clang/test/SemaObjC/arc.m Line 117: assigning '__strong id *' to '__autoreleasing id *' changes retain/release properties of pointer
1 error generated.

[rjmccall]

Yeah, looks like returning true causes the variable to be marked as invalid (not unreasonable, since maybe its type is wrong), which causes downstream diagnostics to be suppressed.

Both test cases should probably be fixed to assign into a different variable so that we continue to test the diagnostic.

[Anastasia]

• Always set isInvalid for all error cases.
• Hoist setting isInvalid together with an error diagnostic.
• Updated more tests.

[rjmccall]

LGTM, thanks!

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_incompatible_qualified_id : Warning<
   "|%diff{converting $ to incompatible type $|"
   "converting type to incompatible type}0,1"
   "|%diff{initializing $ with an expression of incompatible type $|"
   "initializing type with an expression of incompatible type}0,1"
   "|%diff{sending $ to parameter of incompatible type $|"
   "sending type to parameter of incompatible type}0,1"
   "|%diff{casting $ to incompatible type $|"
   "casting type to incompatible type}0,1}2">;
+def err_incompatible_qualified_id : Error<
+  "%select{%diff{assigning to $ from incompatible type $|"
+  "assigning to type from incompatible type}0,1"
+  "|%diff{passing $ to parameter of incompatible type $|"
+  "passing type to parameter of incompatible type}0,1"
+  "|%diff{returning $ from a function with incompatible result type $|"
+  "returning type from a function with incompatible result type}0,1"
+  "|%diff{converting $ to incompatible type $|"
+  "converting type to incompatible type}0,1"
+  "|%diff{initializing $ with an expression of incompatible type $|"
+  "initializing type with an expression of incompatible type}0,1"
+  "|%diff{sending $ to parameter of incompatible type $|"
+  "sending type to parameter of incompatible type}0,1"
+  "|%diff{casting $ to incompatible type $|"
+  "casting type to incompatible type}0,1}2">;
 def ext_typecheck_convert_pointer_int : ExtWarn<
   "incompatible pointer to integer conversion "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   "%select{|; dereference with *|"
   "; take the address with &|"
   "; remove *|"
   "; remove &}3">,
   InGroup<IntConversion>;
+def err_typecheck_convert_pointer_int : Error<
+  "incompatible pointer to integer conversion "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">;
 def ext_typecheck_convert_int_pointer : ExtWarn<
   "incompatible integer to pointer conversion "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   "%select{|; dereference with *|"
   "; take the address with &|"
   "; remove *|"
   "; remove &}3">,
   InGroup<IntConversion>, SFINAEFailure;
+def err_typecheck_convert_int_pointer : Error<
+  "incompatible integer to pointer conversion "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">;
 def ext_typecheck_convert_pointer_void_func : Extension<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   " converts between void pointer and function pointer">;
+def err_typecheck_convert_pointer_void_func : Error<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " converts between void pointer and function pointer">;
 def ext_typecheck_convert_incompatible_pointer_sign : ExtWarn<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   " converts between pointers to integer types with different sign">,
   InGroup<DiagGroup<"pointer-sign">>;
+def err_typecheck_convert_incompatible_pointer_sign : Error<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " converts between pointers to integer types with different sign">;
 def ext_typecheck_convert_incompatible_pointer : ExtWarn<
   "incompatible pointer types "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   "%select{|; dereference with *|"
   "; take the address with &|"
   "; remove *|"
   "; remove &}3">,
   InGroup<IncompatiblePointerTypes>;
+def err_typecheck_convert_incompatible_pointer : Error<
+  "incompatible pointer types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">;
 def ext_typecheck_convert_incompatible_function_pointer : ExtWarn<
   "incompatible function pointer types "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   "%select{|; dereference with *|"
   "; take the address with &|"
   "; remove *|"
   "; remove &}3">,
   InGroup<IncompatibleFunctionPointerTypes>;
+def err_typecheck_convert_incompatible_function_pointer : Error<
+  "incompatible function pointer types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  "%select{|; dereference with *|"
+  "; take the address with &|"
+  "; remove *|"
+  "; remove &}3">;
 def ext_typecheck_convert_discards_qualifiers : ExtWarn<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   " discards qualifiers">,
   InGroup<IncompatiblePointerTypesDiscardsQualifiers>;
+def err_typecheck_convert_discards_qualifiers : Error<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " discards qualifiers">;
 def ext_nested_pointer_qualifier_mismatch : ExtWarn<
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2"
   " discards qualifiers in nested pointer types">,
   InGroup<IncompatiblePointerTypesDiscardsQualifiers>;
+def err_nested_pointer_qualifier_mismatch : Error<
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2"
+  " discards qualifiers in nested pointer types">;
 def warn_incompatible_vectors : Warning<
   "incompatible vector types "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"
   "|%diff{initializing $ with an expression of type $|"
   "initializing with expression of different type}0,1"
   "|%diff{sending $ to parameter of type $|"
   "sending to parameter of different type}0,1"
   "|%diff{casting $ to type $|casting between types}0,1}2">,
   InGroup<VectorConversion>, DefaultIgnore;
+def err_incompatible_vectors : Error<
+  "incompatible vector types "
+  "%select{%diff{assigning to $ from $|assigning to different types}0,1"
+  "|%diff{passing $ to parameter of type $|"
+  "passing to parameter of different type}0,1"
+  "|%diff{returning $ from a function with result type $|"
+  "returning from function with different return type}0,1"
+  "|%diff{converting $ to type $|converting between types}0,1"
+  "|%diff{initializing $ with an expression of type $|"
+  "initializing with expression of different type}0,1"
+  "|%diff{sending $ to parameter of type $|"
+  "sending to parameter of different type}0,1"
+  "|%diff{casting $ to type $|casting between types}0,1}2">;
 def err_int_to_block_pointer : Error<
   "invalid block pointer conversion "
   "%select{%diff{assigning to $ from $|assigning to different types}0,1"
   "|%diff{passing $ to parameter of type $|"
   "passing to parameter of different type}0,1"
   "|%diff{returning $ from a function with result type $|"
   "returning from function with different return type}0,1"
   "|%diff{converting $ to type $|converting between types}0,1"

clang/include/clang/Sema/Sema.h

enum AssignConvertType {
     /// FunctionVoidPointer - The assignment is between a function pointer and
     /// void*, which the standard doesn't allow, but we accept as an extension.
     FunctionVoidPointer,
 
     /// IncompatiblePointer - The assignment is between two pointers types that
     /// are not compatible, but we accept them as an extension.
     IncompatiblePointer,
 
+    /// IncompatibleFunctionPointer - The assignment is between two function
+    /// pointers types that are not compatible, but we accept them as an
+    /// extension.
+    IncompatibleFunctionPointer,
+
     /// IncompatiblePointerSign - The assignment is between two pointers types
     /// which point to integers which have a different sign, but are otherwise
     /// identical. This is a subset of the above, but broken out because it's by
     /// far the most common case of incompatible pointers.
     IncompatiblePointerSign,
 
     /// CompatiblePointerDiscardsQualifiers - The assignment discards
     /// c/v/r qualifiers, which we accept as an extension.

clang/lib/Sema/SemaExpr.cpp

if (isa<PointerType>(lhptee) && isa<PointerType>(rhptee)) {
 
       } while (isa<PointerType>(lhptee) && isa<PointerType>(rhptee));
 
       if (lhptee == rhptee)
         return Sema::IncompatibleNestedPointerQualifiers;
     }
 
     // General pointer incompatibility takes priority over qualifiers.
+    if (RHSType->isFunctionPointerType() && LHSType->isFunctionPointerType())
+      return Sema::IncompatibleFunctionPointer;
     return Sema::IncompatiblePointer;
   }
   if (!S.getLangOpts().CPlusPlus &&
       S.IsFunctionConversion(ltrans, rtrans, ltrans))
-    return Sema::IncompatiblePointer;
+    return Sema::IncompatibleFunctionPointer;
   return ConvTy;
 }
 
 /// checkBlockPointerTypesForAssignment - This routine determines whether two
 /// block pointer types are compatible or whether a block and normal pointer
 /// are compatible. It is more restrict than comparing two function pointer
 // types.
 static Sema::AssignConvertType
bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy,
   const ObjCProtocolDecl *PDecl = nullptr;
 
   switch (ConvTy) {
   case Compatible:
       DiagnoseAssignmentEnum(DstType, SrcType, SrcExpr);
       return false;
 
   case PointerToInt:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_pointer_int;
+      isInvalid = true;
+    } else {
       DiagKind = diag::ext_typecheck_convert_pointer_int;
+    }
     ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
     MayHaveConvFixit = true;
     break;
   case IntToPointer:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_int_pointer;
+      isInvalid = true;
+    } else {
       DiagKind = diag::ext_typecheck_convert_int_pointer;
+    }
+    ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
+    MayHaveConvFixit = true;
+    break;
+  case IncompatibleFunctionPointer:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_incompatible_function_pointer;
+      isInvalid = true;
+    } else {
+      DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
+    }
     ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
     MayHaveConvFixit = true;
     break;
   case IncompatiblePointer:
-    if (Action == AA_Passing_CFAudited)
+    if (Action == AA_Passing_CFAudited) {
       DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;
-    else if (SrcType->isFunctionPointerType() &&
-             DstType->isFunctionPointerType())
-      DiagKind = diag::ext_typecheck_convert_incompatible_function_pointer;
-    else
+    } else if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_incompatible_pointer;
+      isInvalid = true;
+    } else {
       DiagKind = diag::ext_typecheck_convert_incompatible_pointer;
-
+    }
     CheckInferredResultType = DstType->isObjCObjectPointerType() &&
       SrcType->isObjCObjectPointerType();
     if (Hint.isNull() && !CheckInferredResultType) {
       ConvHints.tryToFixConversion(SrcExpr, SrcType, DstType, *this);
     }
     else if (CheckInferredResultType) {
       SrcType = SrcType.getUnqualifiedType();
       DstType = DstType.getUnqualifiedType();
     }
     MayHaveConvFixit = true;
     break;
   case IncompatiblePointerSign:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_incompatible_pointer_sign;
+      isInvalid = true;
+    } else {
       DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign;
+    }
     break;
   case FunctionVoidPointer:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_typecheck_convert_pointer_void_func;
+      isInvalid = true;
+    } else {
       DiagKind = diag::ext_typecheck_convert_pointer_void_func;
+    }
     break;
   case IncompatiblePointerDiscardsQualifiers: {
     // Perform array-to-pointer decay if necessary.
     if (SrcType->isArrayType()) SrcType = Context.getArrayDecayedType(SrcType);
 
+    isInvalid = true;
+
     Qualifiers lhq = SrcType->getPointeeType().getQualifiers();
     Qualifiers rhq = DstType->getPointeeType().getQualifiers();
     if (lhq.getAddressSpace() != rhq.getAddressSpace()) {
       DiagKind = diag::err_typecheck_incompatible_address_space;
       break;
 
     } else if (lhq.getObjCLifetime() != rhq.getObjCLifetime()) {
       DiagKind = diag::err_typecheck_incompatible_ownership;
case CompatiblePointerDiscardsQualifiers:
     // checkPointerTypesForAssignment. However, that would require a
     // bit of refactoring (so that the second argument is an
     // expression, rather than a type), which should be done as part
     // of a larger effort to fix checkPointerTypesForAssignment for
     // C++ semantics.
     if (getLangOpts().CPlusPlus &&
         IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType))
       return false;
-    DiagKind = diag::ext_typecheck_convert_discards_qualifiers;
+    if (getLangOpts().CPlusPlus) {
+      DiagKind =  diag::err_typecheck_convert_discards_qualifiers;
+      isInvalid = true;
+    } else {
+      DiagKind =  diag::ext_typecheck_convert_discards_qualifiers;
+    }
+
     break;
   case IncompatibleNestedPointerQualifiers:
+    if (getLangOpts().CPlusPlus) {
+      isInvalid = true;
+      DiagKind = diag::err_nested_pointer_qualifier_mismatch;
+    } else {
       DiagKind = diag::ext_nested_pointer_qualifier_mismatch;
+    }
     break;
   case IncompatibleNestedPointerAddressSpaceMismatch:
     DiagKind = diag::err_typecheck_incompatible_nested_address_space;
+    isInvalid = true;
     break;
   case IntToBlockPointer:
     DiagKind = diag::err_int_to_block_pointer;
+    isInvalid = true;
     break;
   case IncompatibleBlockPointer:
     DiagKind = diag::err_typecheck_convert_incompatible_block_pointer;
+    isInvalid = true;
     break;
   case IncompatibleObjCQualifiedId: {
     if (SrcType->isObjCQualifiedIdType()) {
       const ObjCObjectPointerType *srcOPT =
                 SrcType->castAs<ObjCObjectPointerType>();
       for (auto *srcProto : srcOPT->quals()) {
         PDecl = srcProto;
         break;
       }
       if (const ObjCInterfaceType *IFaceT =
             DstType->castAs<ObjCObjectPointerType>()->getInterfaceType())
         IFace = IFaceT->getDecl();
     }
     else if (DstType->isObjCQualifiedIdType()) {
       const ObjCObjectPointerType *dstOPT =
         DstType->castAs<ObjCObjectPointerType>();
       for (auto *dstProto : dstOPT->quals()) {
         PDecl = dstProto;
         break;
       }
       if (const ObjCInterfaceType *IFaceT =
             SrcType->castAs<ObjCObjectPointerType>()->getInterfaceType())
         IFace = IFaceT->getDecl();
     }
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_incompatible_qualified_id;
+      isInvalid = true;
+    } else {
       DiagKind = diag::warn_incompatible_qualified_id;
+    }
     break;
   }
   case IncompatibleVectors:
+    if (getLangOpts().CPlusPlus) {
+      DiagKind = diag::err_incompatible_vectors;
+      isInvalid = true;
+    } else {
       DiagKind = diag::warn_incompatible_vectors;
+    }
     break;
   case IncompatibleObjCWeakRef:
     DiagKind = diag::err_arc_weak_unavailable_assign;
+    isInvalid = true;
     break;
   case Incompatible:
     if (maybeDiagnoseAssignmentToFunction(*this, DstType, SrcExpr)) {
       if (Complained)
         *Complained = true;
       return true;
     }
 
if (!ConvHints.isNull()) {
     FDiag << Hint;
   }
   if (MayHaveConvFixit) { FDiag << (unsigned) (ConvHints.Kind); }
 
   if (MayHaveFunctionDiff)
     HandleFunctionTypeMismatch(FDiag, SecondType, FirstType);
 
   Diag(Loc, FDiag);
-  if (DiagKind == diag::warn_incompatible_qualified_id &&
+  if ((DiagKind == diag::warn_incompatible_qualified_id ||
+       DiagKind == diag::err_incompatible_qualified_id) &&
       PDecl && IFace && !IFace->hasDefinition())
-      Diag(IFace->getLocation(), diag::note_incomplete_class_and_qualified_id)
         << IFace << PDecl;
 
   if (SecondType == Context.OverloadTy)
     NoteAllOverloadCandidates(OverloadExpr::find(SrcExpr).Expression,
                               FirstType, /*TakingAddress=*/true);
 
   if (CheckInferredResultType)
     EmitRelatedResultTypeNote(SrcExpr);

clang/lib/Sema/SemaExprCXX.cpp

ICS.DiagnoseAmbiguousConversion(*this, From->getExprLoc(),
                           PDiag(diag::err_typecheck_ambiguous_condition)
                             << From->getSourceRange());
     return ExprError();
 
   case ImplicitConversionSequence::EllipsisConversion:
     llvm_unreachable("Cannot perform an ellipsis conversion");
 
   case ImplicitConversionSequence::BadConversion:
-    bool Diagnosed =
-        DiagnoseAssignmentResult(Incompatible, From->getExprLoc(), ToType,
-                                 From->getType(), From, Action);
+    Sema::AssignConvertType ConvTy =
+        CheckAssignmentConstraints(From->getExprLoc(), ToType, From->getType());
+    bool Diagnosed = DiagnoseAssignmentResult(
+        ConvTy == Compatible ? Incompatible : ConvTy, From->getExprLoc(),
+        ToType, From->getType(), From, Action);
     assert(Diagnosed && "failed to diagnose bad conversion"); (void)Diagnosed;
     return ExprError();
   }
 
   // Everything went well.
   return From;
 }
 
 /// PerformImplicitConversion - Perform an implicit conversion of the
 /// expression From to the type ToType by following the standard
 /// conversion sequence SCS. Returns the converted
 /// expression. Flavor is the context in which we're performing this
 /// conversion, for use in error messages.
 ExprResult

clang/test/CXX/conv/conv.fctptr/p1.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s -triple x86_64-unknown-unknown
 
 struct S;
 
 typedef void Nothrow() noexcept;
 typedef void Throw();
 
 Nothrow *a;
 Throw *b;
 Nothrow S::*c;
 Throw S::*d;
 
 void test() {
-  a = b; // expected-error {{assigning to 'Nothrow *' (aka 'void (*)() noexcept') from incompatible type 'Throw *' (aka 'void (*)()'): different exception specifications}}
+  a = b; // expected-error {{incompatible function pointer types assigning to 'Nothrow *' (aka 'void (*)() noexcept') from 'Throw *' (aka 'void (*)()')}}
   b = a;
   c = d; // expected-error {{assigning to 'Nothrow S::*' from incompatible type 'Throw S::*': different exception specifications}}
   d = c;
 
   // Function pointer conversions do not combine properly with qualification conversions.
   // FIXME: This seems like a defect.
   Nothrow *const *pa = b; // expected-error {{cannot initialize}}
   Throw *const *pb = a; // expected-error {{cannot initialize}}

clang/test/CXX/drs/dr3xx.cpp

void f(P p, Q q, Q2 q2, R r, S s, T t) {
     q = p; // ok
     q2 = p; // ok
     r = p; // expected-error {{incompatible}}
     s = p; // expected-error {{incompatible}} (for now)
     t = p; // expected-error {{incompatible}}
     s = q; // expected-error {{incompatible}}
     s = q2; // expected-error {{incompatible}}
     s = t; // ok, adding const
-    t = s; // expected-error {{incompatible}}
+    t = s; // expected-error {{discards qualifiers}}
     (void) const_cast<P>(q);
     (void) const_cast<P>(q2);
     (void) const_cast<Q>(p);
     (void) const_cast<Q2>(p);
     (void) const_cast<S>(p); // expected-error {{not allowed}} (for now)
     (void) const_cast<P>(s); // expected-error {{not allowed}} (for now)
     (void) const_cast<S>(q); // expected-error {{not allowed}}
     (void) const_cast<S>(q2); // expected-error {{not allowed}}

clang/test/CXX/except/except.handle/p16.cpp

 // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -fsyntax-only -verify %s
 
 // The object declared in an exception-declaration or, if the
 // exception-declaration does not specify a name, a temporary (12.2)
 // is copy-initialized (8.5) from the exception object.
 //
 template<typename T>
 class X {
   T* ptr;
 
 public:
   X(const X<T> &) {
     int *ip = 0;
-    ptr = ip; // expected-error{{assigning to 'float *' from incompatible type 'int *'}}
+    ptr = ip; // expected-error{{incompatible pointer types assigning to 'float *' from 'int *'}}
   }
 
   ~X() {
     float *fp = 0;
-    ptr = fp; // expected-error{{assigning to 'int *' from incompatible type 'float *'}}
+    ptr = fp; // expected-error{{incompatible pointer types assigning to 'int *' from 'float *'}}
   }
 };
 
 void f() {
   try {
   } catch (X<float>) { // expected-note{{instantiation}}
     // copy constructor
   } catch (X<int> xi) { // expected-note{{instantiation}}

clang/test/CXX/expr/p13.cpp

 // RUN: %clang_cc1 -std=c++1z -verify %s -fexceptions -fcxx-exceptions -Wno-dynamic-exception-spec
 
 struct X {};
 struct Y : X {};
 
 using A = void (*)() noexcept;
 using B = void (*)();
 using C = void (X::*)() noexcept;
 using D = void (X::*)();
 using E = void (Y::*)() noexcept;
 using F = void (Y::*)();
 
 void f(A a, B b, C c, D d, E e, F f, bool k) {
-  a = k ? a : b; // expected-error {{different exception specifications}}
+  a = k ? a : b; // expected-error {{incompatible function pointer types assigning to 'A' (aka 'void (*)() noexcept') from 'void (*)()'}}
   b = k ? a : b;
 
   c = k ? c : d; // expected-error {{different exception specifications}}
   d = k ? c : d;
 
   e = k ? c : f; // expected-error {{different exception specifications}}
   e = k ? d : e; // expected-error {{different exception specifications}}
   f = k ? c : f;

clang/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template<typename T>
 struct X {
   template<typename U> struct Inner { };
   
   template<typename U> void f(T, U) { }
 };
 
 template<> template<typename U>
 struct X<int>::Inner {
   U member;
 };
 
 template<> template<typename U>
 void X<int>::f(int x, U y) { 
-  x = y; // expected-error{{incompatible type}}
+  x = y; // expected-error{{incompatible pointer to integer conversion}}
 }
 
 void test(X<int> xi, X<long> xl, float *fp) {
   X<int>::Inner<float*> xii;
   xii.member = fp;
   xi.f(17, 25);
   xi.f(17, 3.14159);
   xi.f(17, fp); // expected-note{{instantiation}}
   X<long>::Inner<float*> xli;
   
   xli.member = fp; // expected-error{{no member}}
   xl.f(17, fp); // okay
 }

clang/test/CXX/temp/temp.spec/temp.explicit/p10.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template<typename T>
 struct X0 {
   void f(T&);
   
   struct Inner;
   
   static T static_var;
 };
 
 template<typename T>
 void X0<T>::f(T& t) { 
-  t = 1; // expected-error{{incompatible type}}
+  t = 1; // expected-error{{incompatible integer to pointer conversion}}
 }
 
 template<typename T>
 struct X0<T>::Inner {
   T member;
 };
 
 template<typename T>

clang/test/CXX/temp/temp.spec/temp.explicit/p9.cpp

 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
 
 template<typename T>
 struct X0 {
   void f(T &t) {
-    t = 1; // expected-error{{incompatible type}}
+    t = 1; // expected-error{{incompatible integer to pointer conversion}}
   }
   
   void g(T &t);
   
   void h(T &t);
   
   static T static_var;
 };
 
 template<typename T>
 inline void X0<T>::g(T & t) {
-  t = 1; // expected-error{{incompatible type}}
+  t = 1; // expected-error{{incompatible integer to pointer conversion}}
 }
 
 template<typename T>
 void X0<T>::h(T & t) {
   t = 1;
 }
 
 template<typename T>
 T X0<T>::static_var = 1;
 
 extern template struct X0<int*>;
 
 int *&test(X0<int*> xi, int *ip) {
   xi.f(ip); // expected-note{{instantiation}}
   xi.g(ip); // expected-note{{instantiation}}
   xi.h(ip);
   return X0<int*>::static_var;
 }
 
 template<typename T>
 void f0(T& t) {
-  t = 1; // expected-error{{incompatible type}}
+  t = 1; // expected-error{{incompatible integer to pointer conversion}}
 }
 
 template<typename T>
 inline void f1(T& t) {
-  t = 1; // expected-error 2{{incompatible type}}
+  t = 1; // expected-error 2{{incompatible integer to pointer conversion}}
 }
 
 extern template void f0<>(int *&);
 extern template void f1<>(int *&);
 
 void test_f0(int *ip, float *fp) {
   f0(ip);
   f0(fp); // expected-note{{instantiation}}
 }
 
 void test_f1(int *ip, float *fp) {
   f1(ip); // expected-note{{instantiation}}
   f1(fp); // expected-note{{instantiation}}
 }

clang/test/OpenMP/allocate_allocator_messages.cpp

 extern const omp_allocator_handle_t omp_low_lat_mem_alloc;
 extern const omp_allocator_handle_t omp_cgroup_mem_alloc;
 extern const omp_allocator_handle_t omp_pteam_mem_alloc;
 extern const omp_allocator_handle_t omp_thread_mem_alloc;
 
 struct St1{
  int a;
  static int b;
-#pragma omp allocate(b) allocator(sss) // expected-error {{initializing 'const omp_allocator_handle_t' (aka 'void **const') with an expression of incompatible type 'int'}} expected-note {{previous allocator is specified here}}
+#pragma omp allocate(b) allocator(sss) // expected-error {{incompatible integer to pointer conversion initializing 'const omp_allocator_handle_t' (aka 'void **const') with an expression of type 'int'}} expected-note {{previous allocator is specified here}}
 #pragma omp allocate(b)
 #pragma omp allocate(b) allocator(omp_thread_mem_alloc) // expected-warning {{allocate directive specifies 'omp_thread_mem_alloc' allocator while previously used default}}
 } d; // expected-note 2 {{'d' defined here}}
 
 // expected-error@+1 {{expected one of the predefined allocators for the variables with the static storage: 'omp_default_mem_alloc', 'omp_large_cap_mem_alloc', 'omp_const_mem_alloc', 'omp_high_bw_mem_alloc', 'omp_low_lat_mem_alloc', 'omp_cgroup_mem_alloc', 'omp_pteam_mem_alloc' or 'omp_thread_mem_alloc'}}
 #pragma omp allocate(d) allocator(nullptr)
 extern void **allocator;
 // expected-error@+1 {{expected one of the predefined allocators for the variables with the static storage: 'omp_default_mem_alloc', 'omp_large_cap_mem_alloc', 'omp_const_mem_alloc', 'omp_high_bw_mem_alloc', 'omp_low_lat_mem_alloc', 'omp_cgroup_mem_alloc', 'omp_pteam_mem_alloc' or 'omp_thread_mem_alloc'}}
 #pragma omp allocate(d) allocator(allocator)
 #pragma omp allocate(d) allocator(omp_thread_mem_alloc) // expected-note {{previous allocator is specified here}}
 #pragma omp allocate(d) // expected-warning {{allocate directive specifies default allocator while previously used 'omp_thread_mem_alloc'}}
 
 int c;
 #pragma omp allocate(c) allocator(omp_thread_mem_alloc) // expected-note {{previous allocator is specified here}}
 #pragma omp allocate(c) allocator(omp_high_bw_mem_alloc) // expected-warning {{allocate directive specifies 'omp_high_bw_mem_alloc' allocator while previously used 'omp_thread_mem_alloc'}}
 

clang/test/Sema/block-call.c

int main() {
 
   int (^IPCC4) (int, char (^CArg) (double));
 
   int (^IPCC5) (int, char (^CArg) (double)) = IPCC4;
 
   int (^IPCC6) (int, char (^CArg) (float))  = IPCC4; // expected-error {{incompatible block pointer types initializing 'int (^)(int, char (^)(float))' with an expression of type 'int (^)(int, char (^)(double))'}}
 
   IPCC2 = 0;
-  IPCC2 = 1; // expected-error {{invalid block pointer conversion assigning to 'int *(^)()' from 'int'}}
+  IPCC1 = 1; // expected-error {{invalid block pointer conversion assigning to 'int *const (^)()' from 'int'}}
   int (^x)() = 0;
   int (^y)() = 3;   // expected-error {{invalid block pointer conversion initializing 'int (^)()' with an expression of type 'int'}}
   int a = 1;
   int (^z)() = a+4;   // expected-error {{invalid block pointer conversion initializing 'int (^)()' with an expression of type 'int'}}
 }
 
 int blah() {
   int (^IFP) (float);
   char (^PCP)(double, double, char);
 
   IFP(1.0);
   IFP (1.0, 2.0); // expected-error {{too many arguments to block call}}
 
   char ch = PCP(1.0, 2.0, 'a');
   return PCP(1.0, 2.0);   // expected-error {{too few arguments to block}}
 }

clang/test/Sema/block-return.c

static int funk(char *s) {
   if (^{} == ((void*)0))
     return 1;
   else 
     return 0;
 }
 void next();
 void foo4() {
   int (^xx)(const char *s) = ^(char *s) { return 1; }; // expected-error {{incompatible block pointer types initializing 'int (^)(const char *)' with an expression of type 'int (^)(char *)'}}
-  int (*yy)(const char *s) = funk; // expected-warning {{incompatible pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'}}
+  int (*yy)(const char *s) = funk; // expected-warning {{incompatible function pointer types initializing 'int (*)(const char *)' with an expression of type 'int (char *)'}}
   
   int (^nested)(char *s) = ^(char *str) { void (^nest)(void) = ^(void) { printf("%s\n", str); }; next(); return 1; }; // expected-warning{{implicitly declaring library function 'printf' with type 'int (const char *, ...)'}} \
   // expected-note{{include the header <stdio.h> or explicitly provide a declaration for 'printf'}}
 }
 
 typedef void (^bptr)(void);
 
 bptr foo5(int j) {

clang/test/Sema/callingconv-ms_abi.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-pc-win32 %s
 
 void __attribute__((ms_abi)) foo(void);
 void (*pfoo)(void) = foo;
 
 void __attribute__((sysv_abi)) bar(void);
-void (*pbar)(void) = bar; // expected-warning{{incompatible pointer types}}
+void (*pbar)(void) = bar; // expected-warning{{incompatible function pointer types}}
 
-void (__attribute__((sysv_abi)) *pfoo2)(void) = foo; // expected-warning{{incompatible pointer types}}
+void (__attribute__((sysv_abi)) *pfoo2)(void) = foo; // expected-warning{{incompatible function pointer types}}

clang/test/Sema/callingconv-sysv_abi.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-pc-linux-gnu %s
 
 void __attribute__((ms_abi)) foo(void);
-void (*pfoo)(void) = foo; // expected-warning{{incompatible pointer types}}
+void (*pfoo)(void) = foo; // expected-warning{{incompatible function pointer types}}
 
 void __attribute__((sysv_abi)) bar(void);
 void (*pbar)(void) = bar;
 
-void (__attribute__((ms_abi)) *pbar2)(void) = bar; // expected-warning{{incompatible pointer types}}
+void (__attribute__((ms_abi)) *pbar2)(void) = bar; // expected-warning{{incompatible function pointer types}}

clang/test/Sema/callingconv.c

 void __attribute__((cdecl)) ctest0() {}
 
 void __attribute__((cdecl(1))) ctest1(float x) {} // expected-error {{'cdecl' attribute takes no arguments}}
 
 void (__attribute__((fastcall)) *pfoo)(float*) = foo;
 
 void (__attribute__((stdcall)) *pbar)(float*) = bar;
 
-void (__attribute__((cdecl)) *ptest1)(void) = test1; // expected-warning {{incompatible pointer types}}
+void (__attribute__((cdecl)) *ptest1)(void) = test1; // expected-warning {{incompatible function pointer types}}
 
 void (*pctest0)() = ctest0;
 
 void ctest2() {}
 void (__attribute__((cdecl)) *pctest2)() = ctest2;
 
 typedef void (__attribute__((fastcall)) *Handler) (float *);
 Handler H = foo;

clang/test/Sema/overloadable.c

 int *accept_funcptr(int (*)()) __attribute__((overloadable)); //         \
   // expected-note{{candidate function}}
 float *accept_funcptr(int (*)(int, double)) __attribute__((overloadable)); //  \
   // expected-note{{candidate function}}
 
 void test_funcptr(int (*f1)(int, double),
                   int (*f2)(int, float)) {
   float *fp = accept_funcptr(f1);
-  accept_funcptr(f2); // expected-error{{call to 'accept_funcptr' is ambiguous}}
+  accept_funcptr(f2); // expected-error{{no matching function for call to 'accept_funcptr'}}
 }
 
 struct X { int x; float y; };
 struct Y { int x; float y; };
 int* accept_struct(struct X x) __attribute__((__overloadable__));
 float* accept_struct(struct Y y) __attribute__((overloadable));
 
 void test_struct(struct X x, struct Y y) {
void fn_type_conversions() {
   void (*specific1)(int *) = (void (*)(void *))&foo; // expected-warning{{incompatible function pointer types initializing 'void (*)(int *)' with an expression of type 'void (*)(void *)'}}
   void *specific2 = (void (*)(void *))&foo;
 
   void disabled(void *c) __attribute__((overloadable, enable_if(0, "")));
   void disabled(int *c) __attribute__((overloadable, enable_if(c, "")));
   void disabled(char *c) __attribute__((overloadable, enable_if(1, "The function name lies.")));
   // To be clear, these should all point to the last overload of 'disabled'
   void (*dptr1)(char *c) = &disabled;
-  void (*dptr2)(void *c) = &disabled; // expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function made ineligible by enable_if}} expected-note@-3{{candidate function has type mismatch at 1st parameter (expected 'void *' but has 'char *')}}
-  void (*dptr3)(int *c) = &disabled; // expected-warning{{incompatible pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'}} expected-note@-6{{candidate function made ineligible by enable_if}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function has type mismatch at 1st parameter (expected 'int *' but has 'char *')}}
+  void (*dptr2)(void *c) = &disabled; // expected-warning{{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function made ineligible by enable_if}} expected-note@-3{{candidate function has type mismatch at 1st parameter (expected 'void *' but has 'char *')}}
+  void (*dptr3)(int *c) = &disabled; // expected-warning{{incompatible function pointer types initializing 'void (*)(int *)' with an expression of type '<overloaded function type>'}} expected-note@-6{{candidate function made ineligible by enable_if}} expected-note@-5{{candidate function made ineligible by enable_if}} expected-note@-4{{candidate function has type mismatch at 1st parameter (expected 'int *' but has 'char *')}}
 
   void *specific_disabled = &disabled;
 }
 
 void incompatible_pointer_type_conversions() {
   char charbuf[1];
   unsigned char ucharbuf[1];
   int intbuf[1];

clang/test/Sema/pass-object-size.c

 
 // char* inestead of void* is intentional
 void IsOverloaded(char *p) overloaded; // expected-note{{passing argument to parameter 'p' here}} expected-note 2 {{type mismatch}}
 
 void FunctionPtrs() {
   void (*p)(void *) = NotOverloaded; //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
   void (*p2)(void *) = &NotOverloaded; //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
 
-  void (*p3)(void *) = IsOverloaded; //expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}}
-  void (*p4)(void *) = &IsOverloaded; //expected-warning{{incompatible pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}}
+  void (*p3)(void *) = IsOverloaded; //expected-warning{{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}}
+  void (*p4)(void *) = &IsOverloaded; //expected-warning{{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type '<overloaded function type>'}}
 
   void (*p5)(char *) = IsOverloaded;
   void (*p6)(char *) = &IsOverloaded;
 
   TakeFn(NotOverloaded); //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
   TakeFn(&NotOverloaded); //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}
 
   TakeFnOvl(NotOverloaded); //expected-error{{cannot take address of function 'NotOverloaded' because parameter 1 has pass_object_size attribute}}

clang/test/Sema/preserve-call-conv.c

 // RUN: %clang_cc1 %s -fsyntax-only -triple x86_64-unknown-unknown -verify
 // RUN: %clang_cc1 %s -fsyntax-only -triple arm64-unknown-unknown -verify
 // RUN: %clang_cc1 %s -fsyntax-only -triple x86_64-unknown-windows-msvc -verify
 // RUN: %clang_cc1 %s -fsyntax-only -triple aarch64-unknown-windows-msvc -verify
 // RUN: %clang_cc1 %s -fsyntax-only -triple thumbv7-unknown-windows-msvc -verify
 
 typedef void typedef_fun_t(int);
 
 void __attribute__((preserve_most)) foo(void *ptr) {
 }
 
 void __attribute__((preserve_most(1))) foo1(void *ptr) { // expected-error {{'preserve_most' attribute takes no arguments}}
 }
 
 void (__attribute__((preserve_most)) *pfoo1)(void *) = foo;
 
-void (__attribute__((cdecl)) *pfoo2)(void *) = foo; // expected-warning {{incompatible pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_most))'}}
-void (*pfoo3)(void *) = foo; // expected-warning {{incompatible pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_most))'}}
+void (__attribute__((cdecl)) *pfoo2)(void *) = foo; // expected-warning {{incompatible function pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_most))'}}
+void (*pfoo3)(void *) = foo; // expected-warning {{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_most))'}}
 
 typedef_fun_t typedef_fun_foo; // expected-note {{previous declaration is here}}
 void __attribute__((preserve_most)) typedef_fun_foo(int x) { } // expected-error {{function declared 'preserve_most' here was previously declared without calling convention}}
 
 struct type_test_foo {} __attribute__((preserve_most));  // expected-warning {{'preserve_most' attribute only applies to functions and methods}}
 
 void __attribute__((preserve_all)) boo(void *ptr) {
 }
 
 void __attribute__((preserve_all(1))) boo1(void *ptr) { // expected-error {{'preserve_all' attribute takes no arguments}}
 }
 
 void (__attribute__((preserve_all)) *pboo1)(void *) = boo;
 
-void (__attribute__((cdecl)) *pboo2)(void *) = boo; // expected-warning {{incompatible pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_all))'}}
-void (*pboo3)(void *) = boo; // expected-warning {{incompatible pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_all))'}}
+void (__attribute__((cdecl)) *pboo2)(void *) = boo; // expected-warning {{incompatible function pointer types initializing 'void (*)(void *) __attribute__((cdecl))' with an expression of type 'void (void *) __attribute__((preserve_all))'}}
+void (*pboo3)(void *) = boo; // expected-warning {{incompatible function pointer types initializing 'void (*)(void *)' with an expression of type 'void (void *) __attribute__((preserve_all))'}}
 
 typedef_fun_t typedef_fun_boo; // expected-note {{previous declaration is here}}
 void __attribute__((preserve_all)) typedef_fun_boo(int x) { } // expected-error {{function declared 'preserve_all' here was previously declared without calling convention}}
 
 struct type_test_boo {} __attribute__((preserve_all));  // expected-warning {{'preserve_all' attribute only applies to functions and methods}}

clang/test/SemaCXX/addr-of-overloaded-function.cpp

 }
 
 namespace test1 {
   void fun(int x) {}
 
   void parameter_number() {
     void (*ptr1)(int, int) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(int, int)' with an rvalue of type 'void (*)(int)': different number of parameters (2 vs 1)}}
     void (*ptr2)(int, int);
-    ptr2 = &fun;  // expected-error {{assigning to 'void (*)(int, int)' from incompatible type 'void (*)(int)': different number of parameters (2 vs 1)}}
+    ptr2 = &fun;  // expected-error {{incompatible function pointer types assigning to 'void (*)(int, int)' from 'void (*)(int)'}}
   }
 
   void parameter_mismatch() {
     void (*ptr1)(double) = &fun; // expected-error {{cannot initialize a variable of type 'void (*)(double)' with an rvalue of type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}}
     void (*ptr2)(double);
-    ptr2 = &fun; // expected-error {{assigning to 'void (*)(double)' from incompatible type 'void (*)(int)': type mismatch at 1st parameter ('double' vs 'int')}}
+    ptr2 = &fun; // expected-error {{incompatible function pointer types assigning to 'void (*)(double)' from 'void (*)(int)'}}
   }
 
   void return_type_test() {
     int (*ptr1)(int) = &fun; // expected-error {{cannot initialize a variable of type 'int (*)(int)' with an rvalue of type 'void (*)(int)': different return type ('int' vs 'void')}}
     int (*ptr2)(int);
-    ptr2 = &fun;  // expected-error {{assigning to 'int (*)(int)' from incompatible type 'void (*)(int)': different return type ('int' vs 'void')}}
+    ptr2 = &fun;  // expected-error {{incompatible function pointer types assigning to 'int (*)(int)' from 'void (*)(int)'}}
   }
 
   int foo(double x, double y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
   int foo(int x, int y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
   int foo(double x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'double')}}
   double foo(float x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
   double foo(int x, float y) {return 0;} // expected-note {{candidate function has different number of parameters (expected 1 but has 2)}}
   double foo(float x) {return 0;} // expected-note {{candidate function has type mismatch at 1st parameter (expected 'int' but has 'float')}}

clang/test/SemaCXX/decl-microsoft-call-conv.cpp

void g(S<void*> s, void* p) {
     s.f(p);
   }
 }
 
 namespace test8 {
   template <typename T>
   struct S {
     void f(T t) { // expected-note {{previous declaration is here}}
-      t = 42; // expected-error {{assigning to 'void *' from incompatible type 'int'}}
+      t = 42; // expected-error {{incompatible integer to pointer conversion assigning to 'void *' from 'int'}}
     }
   };
   template<> void __cdecl S<void*>::f(void*); // expected-error {{function declared 'cdecl' here was previously declared without calling convention}}
   void g(S<void*> s, void* p) {
     s.f(p); // expected-note {{in instantiation of member function 'test8::S<void *>::f' requested here}}
   }
 }
 

clang/test/SemaCXX/goto.cpp

void f(bool b1, bool b2) {
     }
 
   end:
     return;
   }
 }
 
 void g() {
-  end = 1; // expected-error{{assigning to 'double *' from incompatible type 'int'}}
+  end = 1; // expected-error{{incompatible integer to pointer conversion assigning to 'double *' from 'int'}}
 }
 
 void h(int end) {
   {
     goto end; // expected-error{{use of undeclared label 'end'}}
   }
 }
 

clang/test/SemaCXX/int-ptr-cast-SFINAE.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17
 
 void foo(int* a, int *b) {
-  a -= b; // expected-warning {{incompatible integer to pointer conversion assigning to 'int *' from}}
+  a -= b; // expected-error {{incompatible integer to pointer conversion assigning to 'int *' from}}
 }
 
 template<typename T> T declval();
 struct true_type { static const bool value = true; };
 struct false_type { static const bool value = false; };
 template<bool, typename T, typename U> struct select { using type = T; };
 template<typename T, typename U> struct select<false, T, U> { using type = U; };
 

clang/test/SemaCXX/ms-property-error.cpp

public:
   __declspec(property(get=GetX,put=PutX)) T x[];
   T GetX(T i, T j) { return i+j; } // expected-note 3 {{'GetX' declared here}}
   T PutX(T i, T j, T k) { return j = i = k; }  // expected-note 2 {{'PutX' declared here}}
   ~St() {
     x[1] = 0; // expected-error {{too few arguments to function call, expected 3, have 2}}
     x[2][3] = 4;
     ++x[2][3];
     x[1][2] = x[3][4][5]; // expected-error {{too many arguments to function call, expected 2, have 3}}
-    ptr = x[1][2] = x[3][4]; // expected-error {{assigning to 'char *' from incompatible type 'int'}}
+    ptr = x[1][2] = x[3][4]; // expected-error {{incompatible integer to pointer conversion assigning to 'char *' from 'int'}}
   }
 };
 
 // CHECK-LABEL: main
 int main(int argc, char **argv) {
   S *p1 = 0;
   St<float> *p2 = 0;
   St<int> a; // expected-note {{in instantiation of member function 'St<int>::~St' requested here}}
   int j = (p1->x)[223][11][2]; // expected-error {{too many arguments to function call, expected 2, have 3}}
   (p1->x[23]) = argc; // expected-error {{too few arguments to function call, expected 3, have 2}}
   float j1 = (p2->x); // expected-error {{too few arguments to function call, expected 2, have 0}}
   ((p2->x)[23])[1][2] = *argv; // expected-error {{too many arguments to function call, expected 3, have 4}}
   argv = p2->x[11][22] = argc; // expected-error {{assigning to 'char **' from incompatible type 'float'}}
   return ++(((p2->x)[23])); // expected-error {{too few arguments to function call, expected 2, have 1}}
 }

clang/test/SemaObjC/arc.m

void test5() {
   extern void test5_helper(__autoreleasing id *);
   id x;
 
   // Okay because of magic temporaries.
   test5_helper(&x);
 
   __autoreleasing id *a = &x; // expected-error {{initializing '__autoreleasing id *' with an expression of type '__strong id *' changes retain/release properties of pointer}}
 
-  a = &x; // expected-error {{assigning '__strong id *' to '__autoreleasing id *' changes retain/release properties of pointer}}
+  __autoreleasing id *aa;
+  aa = &x; // expected-error {{assigning '__strong id *' to '__autoreleasing id *' changes retain/release properties of pointer}}
 
   extern void test5_helper2(id const *);
   test5_helper2(&x);
 
   extern void test5_helper3(__weak id *); // expected-note {{passing argument to parameter here}}
   test5_helper3(&x); // expected-error {{passing '__strong id *' to parameter of type '__weak id *' changes retain/release properties of pointer}}
 }
 

clang/test/SemaObjC/comptypes-legal.m

 @interface Derived: NSObject
 + (void)registerFunc:(FuncSignature *)function; // expected-note{{passing argument to parameter 'function' here}}
 @end
 
 void foo(void)
 {
   // GCC currently allows this (it has some fiarly new support for covariant return types and contravariant argument types).
   // Since registerFunc: expects a Derived object as it's second argument, I don't know why this would be legal.
-  [Derived registerFunc: ExternFunc];  // expected-warning{{incompatible pointer types sending 'NSObject *(NSObject *, NSObject *)' to parameter of type 'FuncSignature *'}}
+  [Derived registerFunc: ExternFunc];  // expected-warning{{incompatible function pointer types sending 'NSObject *(NSObject *, NSObject *)' to parameter of type 'FuncSignature *' (aka 'id (*)(NSObject *, Derived *)')}}
 }
 
 // rdar://10751015
 @protocol NSCopying @end
 @interface I
 - (void) Meth : (id <NSCopying>)aKey; // expected-note {{passing argument to parameter 'aKey' here}}
 @end
 

clang/test/SemaObjCXX/arc-type-conversion.mm

void test_functional_cast(__strong id *sip, __weak id *wip,
   (void)const_autoreleasing_id_pointer(aip);
   (void)const_autoreleasing_id_pointer(wip); // expected-error{{functional-style cast from '__weak id *' to 'const_autoreleasing_id_pointer' (aka 'const __autoreleasing id *') casts away qualifiers}}
 }
 
 void test_unsafe_unretained(__strong id *sip, __weak id *wip,
                             __autoreleasing id *aip,
                             __unsafe_unretained id *uip,
                             const __unsafe_unretained id *cuip) {
-  uip = sip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__strong id *'}}
-  uip = wip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__weak id *'}}
-  uip = aip; // expected-error{{assigning to '__unsafe_unretained id *' from incompatible type '__autoreleasing id *'}}
+  uip = sip; // expected-error{{assigning '__strong id *' to '__unsafe_unretained id *' changes retain/release properties of pointer}}
+  uip = wip; // expected-error{{assigning '__weak id *' to '__unsafe_unretained id *' changes retain/release properties of pointer}}
+  uip = aip; // expected-error{{assigning '__autoreleasing id *' to '__unsafe_unretained id *' changes retain/release properties of pointer}}
 
   cuip = sip;
-  cuip = wip; // expected-error{{assigning to '__unsafe_unretained id const *' from incompatible type '__weak id *'}}
+  cuip = wip; // expected-error{{assigning '__weak id *' to '__unsafe_unretained id const *' changes retain/release properties of pointer}}
   cuip = aip;
 }
 
 void to_void(__strong id *sip, __weak id *wip,
              __autoreleasing id *aip,
              __unsafe_unretained id *uip) {
   void *vp1 = sip;
   void *vp2 = wip;

clang/test/SemaObjCXX/comptypes-1.mm

int main()
   obj = obj_cp; /* Ok  */
   obj = obj_C;  /* Ok  */
   obj = obj_CP; /* Ok  */
 
   /* Assigning to a 'MyClass *' variable should always generate a
      warning, unless done from an 'id'.  */
   obj_c = obj;    /* Ok */
   obj_c = obj_p;  // expected-error {{assigning to 'MyClass *' from incompatible type 'id<MyProtocol>'}}
-  obj_c = obj_cp; // expected-error {{assigning to 'MyClass *' from incompatible type 'MyOtherClass *'}}
-  obj_c = obj_C;  // expected-error {{assigning to 'MyClass *' from incompatible type 'Class'}}
-  obj_c = obj_CP; // expected-error {{assigning to 'MyClass *' from incompatible type 'Class<MyProtocol>'}}
+  obj_c = obj_cp; // expected-error {{incompatible pointer types assigning to 'MyClass *' from 'MyOtherClass *'}}
+  obj_c = obj_C;  // expected-error {{incompatible pointer types assigning to 'MyClass *' from 'Class'}}
+  obj_c = obj_CP; // expected-error {{incompatible pointer types assigning to 'MyClass *' from 'Class<MyProtocol>'}}
 
   /* Assigning to an 'id<MyProtocol>' variable should generate a
      warning if done from a 'MyClass *' (which doesn't implement
      MyProtocol), but not from an 'id' or from a 'MyOtherClass *'
      (which implements MyProtocol).  */
   obj_p = obj;    /* Ok */
   obj_p = obj_c;  // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'MyClass *'}}
   obj_p = obj_cp; /* Ok  */
-  obj_p = obj_C;  // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'Class'}}
+  obj_p = obj_C;  // expected-error {{incompatible pointer types assigning to 'id<MyProtocol>' from 'Class'}}
   obj_p = obj_CP; // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'Class<MyProtocol>'}}
 
   /* Assigning to a 'MyOtherClass *' variable should always generate
      a warning, unless done from an 'id' or an 'id<MyProtocol>' (since
      MyOtherClass implements MyProtocol).  */
   obj_cp = obj;    /* Ok */
-  obj_cp = obj_c;  // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'MyClass *'}}
+  obj_cp = obj_c;  // expected-error {{incompatible pointer types assigning to 'MyOtherClass *' from 'MyClass *'}}
   obj_cp = obj_p;  /* Ok */
-  obj_cp = obj_C;  // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'Class'}}
-  obj_cp = obj_CP; // expected-error {{assigning to 'MyOtherClass *' from incompatible type 'Class<MyProtocol>'}}
+  obj_cp = obj_C;  // expected-error {{incompatible pointer types assigning to 'MyOtherClass *' from 'Class'}}
+  obj_cp = obj_CP; // expected-error {{incompatible pointer types assigning to 'MyOtherClass *' from 'Class<MyProtocol>'}}
 
   obj_C = obj;     // Ok
-  obj_C = obj_p;   // expected-error {{assigning to 'Class' from incompatible type 'id<MyProtocol>'}}
-  obj_C = obj_c;   // expected-error {{assigning to 'Class' from incompatible type 'MyClass *'}}
-  obj_C = obj_cp;  // expected-error {{assigning to 'Class' from incompatible type 'MyOtherClass *'}}
+  obj_C = obj_p;   // expected-error {{incompatible pointer types assigning to 'Class' from 'id<MyProtocol>'}}
+  obj_C = obj_c;   // expected-error {{incompatible pointer types assigning to 'Class' from 'MyClass *'}}
+  obj_C = obj_cp;  // expected-error {{incompatible pointer types assigning to 'Class' from 'MyOtherClass *'}}
   obj_C = obj_CP;  // Ok
 
   obj_CP = obj;     // Ok
   obj_CP = obj_p;   // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'id<MyProtocol>'}}
-  obj_CP = obj_c;   // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'MyClass *}}
-  obj_CP = obj_cp;  // expected-error {{assigning to 'Class<MyProtocol>' from incompatible type 'MyOtherClass *'}}
+  obj_CP = obj_c;   // expected-error {{incompatible pointer types assigning to 'Class<MyProtocol>' from 'MyClass *'}}
+  obj_CP = obj_cp;  // expected-error {{incompatible pointer types assigning to 'Class<MyProtocol>' from 'MyOtherClass *'}}
   obj_CP = obj_C;   // Ok
 
   /* Any comparison involving an 'id' must be without warnings.  */
   if (obj == obj_p) foo();  /* Ok  */ /*Bogus warning here in 2.95.4*/
   if (obj_p == obj) foo();  /* Ok  */
   if (obj == obj_c) foo();  /* Ok  */
   if (obj_c == obj) foo();  /* Ok  */
   if (obj == obj_cp) foo(); /* Ok  */

clang/test/SemaObjCXX/comptypes-7.mm

int main()
   MyClass *obj_c = nil;
   Class obj_C = nil;
 
   int i = 0;
   int *j = nil;
 
   /* These should all generate errors.  */
 
-  obj = i; // expected-error {{assigning to 'id' from incompatible type 'int'}}
-  obj = j; // expected-error {{assigning to 'id' from incompatible type 'int *'}}
+  obj = i; // expected-error {{incompatible integer to pointer conversion assigning to 'id' from 'int'}}
+  obj = j; // expected-error {{incompatible pointer types assigning to 'id' from 'int *'}}
 
-  obj_p = i; // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'int'}}
-  obj_p = j; // expected-error {{assigning to 'id<MyProtocol>' from incompatible type 'int *'}}
+  obj_p = i; // expected-error {{incompatible integer to pointer conversion assigning to 'id<MyProtocol>' from 'int'}}
+  obj_p = j; // expected-error {{incompatible pointer types assigning to 'id<MyProtocol>' from 'int *'}}
 
-  obj_c = i; // expected-error {{assigning to 'MyClass *' from incompatible type 'int'}}
-  obj_c = j; // expected-error {{assigning to 'MyClass *' from incompatible type 'int *'}}
+  obj_c = i; // expected-error {{incompatible integer to pointer conversion assigning to 'MyClass *' from 'int'}}
+  obj_c = j; // expected-error {{incompatible pointer types assigning to 'MyClass *' from 'int *'}}
 
-  obj_C = i; // expected-error {{assigning to 'Class' from incompatible type 'int'}}
-  obj_C = j; // expected-error {{assigning to 'Class' from incompatible type 'int *'}}
-
-  i = obj;   // expected-error {{assigning to 'int' from incompatible type 'id'}}
-  i = obj_p; // expected-error {{assigning to 'int' from incompatible type 'id<MyProtocol>'}}
-  i = obj_c; // expected-error {{assigning to 'int' from incompatible type 'MyClass *'}}
-  i = obj_C; // expected-error {{assigning to 'int' from incompatible type 'Class'}}
-
-  j = obj;   // expected-error {{assigning to 'int *' from incompatible type 'id'}}
-  j = obj_p; // expected-error {{assigning to 'int *' from incompatible type 'id<MyProtocol>'}}
-  j = obj_c; // expected-error {{assigning to 'int *' from incompatible type 'MyClass *'}}
-  j = obj_C; // expected-error {{assigning to 'int *' from incompatible type 'Class'}}
+  obj_C = i; // expected-error {{incompatible integer to pointer conversion assigning to 'Class' from 'int'}}
+  obj_C = j; // expected-error {{incompatible pointer types assigning to 'Class' from 'int *'}}
+
+  i = obj;   // expected-error {{incompatible pointer to integer conversion assigning to 'int' from 'id'}}
+  i = obj_p; // expected-error {{incompatible pointer to integer conversion assigning to 'int' from 'id<MyProtocol>'}}
+  i = obj_c; // expected-error {{incompatible pointer to integer conversion assigning to 'int' from 'MyClass *'}}
+  i = obj_C; // expected-error {{incompatible pointer to integer conversion assigning to 'int' from 'Class'}}
+
+  j = obj;   // expected-error {{incompatible pointer types assigning to 'int *' from 'id'}}
+  j = obj_p; // expected-error {{incompatible pointer types assigning to 'int *' from 'id<MyProtocol>'}}
+  j = obj_c; // expected-error {{incompatible pointer types assigning to 'int *' from 'MyClass *'}}
+  j = obj_C; // expected-error {{incompatible pointer types assigning to 'int *' from 'Class'}}
 
   if (obj == i) foo() ; // expected-error {{comparison between pointer and integer ('id' and 'int')}}
   if (i == obj) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'id')}}
   if (obj == j) foo() ; // expected-error {{comparison of distinct pointer types ('id' and 'int *')}}
   if (j == obj) foo() ; // expected-error {{comparison of distinct pointer types ('int *' and 'id')}}
 
   if (obj_c == i) foo() ; // expected-error {{comparison between pointer and integer ('MyClass *' and 'int')}}
   if (i == obj_c) foo() ; // expected-error {{comparison between pointer and integer ('int' and 'MyClass *')}}

clang/test/SemaObjCXX/instantiate-expr.mm

 
 // Test instantiation of value-dependent ObjCIvarRefExpr,
 // ObjCIsaRefExpr, and ObjCPropertyRefExpr nodes.
 A *get_an_A(unsigned);
 id get_an_id(unsigned);
 
 template<unsigned N, typename T, typename U, typename V>
 void f(U value, V value2) {
-  get_an_A(N)->ivar = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
-  get_an_A(N).prop = value2; // expected-error{{assigning to 'int' from incompatible type 'double *'}}
+  get_an_A(N)->ivar = value; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
+  get_an_A(N).prop = value2; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'double *'}}
   T c = get_an_id(N)->isa; // expected-error{{cannot initialize a variable of type 'int' with an lvalue of type 'Class'}} \
                            // expected-warning 3 {{direct access to Objective-C's isa is deprecated in favor of object_getClass()}}
 }
 
 template void f<6, Class>(int, int); // expected-note{{in instantiation of}}
 template void f<7, Class>(int*, int); // expected-note{{in instantiation of}}
 template void f<8, Class>(int, double*); // expected-note{{in instantiation of}}
 template void f<9, int>(int, int); // expected-note{{in instantiation of}}
 
 // Test instantiation of unresolved member reference expressions to an
 // ivar reference.
 template<typename T, typename U, typename V>
 void f2(T ptr, U value, V value2) {
-  ptr->ivar = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
-  ptr.prop = value2; // expected-error{{assigning to 'int' from incompatible type 'double *'}}
+  ptr->ivar = value; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
+  ptr.prop = value2; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'double *'}}
 }
 
 template void f2(A*, int, int);
 template void f2(A*, int*, int); // expected-note{{instantiation of}}
 template void f2(A*, int, double*); // expected-note{{instantiation of}}
 
 // Test instantiation of unresolved member referfence expressions to
 // an isa.

 // Implicit setter/getter
 @interface B
 - (int)foo;
 - (void)setFoo:(int)value;
 @end
 
 template<typename T>
 void f4(B *b, T value) {
-  b.foo = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+  b.foo = value; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
 }
 
 template void f4(B*, int);
 template void f4(B*, int*); // expected-note{{in instantiation of function template specialization 'f4<int *>' requested here}}
 
 template<typename T, typename U>
 void f5(T ptr, U value) {
-  ptr.foo = value; // expected-error{{assigning to 'int' from incompatible type 'int *'}}
+  ptr.foo = value; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
 }
 
 template void f5(B*, int);
 template void f5(B*, int*); // expected-note{{in instantiation of function template specialization 'f5<B *, int *>' requested here}}

clang/test/SemaObjCXX/instantiate-stmt.mm

 template void fast_enumeration_test<int>(NSArray*); // expected-note{{in instantiation of}}
 template void fast_enumeration_test<NSString *>(vector); // expected-note{{in instantiation of}}
 
 // @try/@catch/@finally
 
 template<typename T, typename U>
 void try_catch_finally_test(U value) {
   @try {
-    value = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
+    value = 1; // expected-error{{incompatible integer to pointer conversion assigning to 'int *' from 'int'}}
   }
   @catch (T obj) { // expected-error{{@catch parameter is not a pointer to an interface type}}
     id x = obj;
   } @finally {
     value = 0;
   }
 }
 
 template void try_catch_finally_test<NSString *>(int);
 template void try_catch_finally_test<NSString *>(int*); // expected-note{{in instantiation of}}
 template void try_catch_finally_test<NSString>(int); // expected-note{{in instantiation of function template specialization 'try_catch_finally_test<NSString, int>' requested here}}

clang/test/SemaObjCXX/noescape.mm

 #if __cplusplus < 201406
   // expected-note@-4 {{template parameter is declared here}}
   // expected-note@-4 {{template parameter is declared here}}
 #endif
 
 void test0() {
   fnptr0 = &func0;
   fnptr0 = &noescapeFunc2;
-  fnptr1 = &func0; // expected-error {{assigning to 'void (*)(__attribute__((noescape)) int *)' from incompatible type 'void (*)(int *)'}}
+  fnptr1 = &func0; // expected-error {{incompatible function pointer types assigning to 'void (*)(__attribute__((noescape)) int *)' from 'void (*)(int *)'}}
   fnptr1 = &noescapeFunc2;
   S4<&func0> e0;
   S4<&noescapeFunc2> e1;
   S5<&func0> ne0;
 
 #if __cplusplus < 201406
   // expected-error@-4 {{non-type template argument of type 'void (*)(__attribute__((noescape)) int *)' cannot be converted to a value of type 'void (*)(int *)'}}
   // expected-error@-4 {{non-type template argument of type 'void (*)(int *)' cannot be converted to a value of type 'void (*)(__attribute__((noescape)) int *)'}}

clang/test/SemaObjCXX/nullability-pragmas.mm

void test_pragmas_1(A * _Nonnull a, AA * _Nonnull aa) {
   f12(0); // okay
   [a method1:0]; // expected-warning{{null passed to a callee that requires a non-null argument}}
 
   f17(a); // expected-error{{no matching function for call to 'f17'}}
   [a method3: a]; // expected-error{{cannot initialize a parameter of type 'NSError * _Nullable * _Nullable' with an lvalue of type 'A * _Nonnull'}}
   [a method4: a]; // expected-error{{cannot initialize a parameter of type 'NSErrorPtr  _Nullable * _Nullable' (aka 'NSError **') with an lvalue of type 'A * _Nonnull'}}
 
   float *ptr;
-  ptr = f13(); // expected-error{{assigning to 'float *' from incompatible type 'int_ptr _Nonnull' (aka 'int *')}}
-  ptr = f14(); // expected-error{{assigning to 'float *' from incompatible type 'A * _Nonnull'}}
-  ptr = [a method1:a]; // expected-error{{assigning to 'float *' from incompatible type 'A * _Nonnull'}}
-  ptr = a.aProp; // expected-error{{assigning to 'float *' from incompatible type 'A * _Nonnull'}}
-  ptr = global_int_ptr; // expected-error{{assigning to 'float *' from incompatible type 'int * _Nonnull'}}
-  ptr = f15(); // expected-error{{assigning to 'float *' from incompatible type 'int * _Null_unspecified'}}
-  ptr = f16(); // expected-error{{assigning to 'float *' from incompatible type 'A * _Null_unspecified'}}
-  ptr = [a method2]; // expected-error{{assigning to 'float *' from incompatible type 'A * _Null_unspecified'}}
+  ptr = f13(); // expected-error{{incompatible pointer types assigning to 'float *' from 'int_ptr _Nonnull' (aka 'int *')}}
+  ptr = f14(); // expected-error{{incompatible pointer types assigning to 'float *' from 'A * _Nonnull'}}
+  ptr = [a method1:a]; // expected-error{{incompatible pointer types assigning to 'float *' from 'A * _Nonnull'}}
+  ptr = a.aProp; // expected-error{{incompatible pointer types assigning to 'float *' from 'A * _Nonnull'}}
+  ptr = global_int_ptr; // expected-error{{incompatible pointer types assigning to 'float *' from 'int * _Nonnull'}}
+  ptr = f15(); // expected-error{{incompatible pointer types assigning to 'float *' from 'int * _Null_unspecified'}}
+  ptr = f16(); // expected-error{{incompatible pointer types assigning to 'float *' from 'A * _Null_unspecified'}}
+  ptr = [a method2]; // expected-error{{incompatible pointer types assigning to 'float *' from 'A * _Null_unspecified'}}
 
-  ptr = aa->ivar1; // expected-error{{from incompatible type 'id'}}
-  ptr = aa->ivar2; // expected-error{{from incompatible type 'id _Nonnull'}}
+  ptr = aa->ivar1; // expected-error{{incompatible pointer types assigning to 'float *' from 'id'}}
+  ptr = aa->ivar2; // expected-error{{incompatible pointer types assigning to 'float *' from 'id _Nonnull'}}
 }
 
 void test_pragmas_generics(void) {
   float *fp;
 
   NSGeneric<C *> *genC;
-  fp = [genC tee]; // expected-error{{from incompatible type 'C *'}}
-  fp = [genC maybeTee]; // expected-error{{from incompatible type 'C * _Nullable'}}
+  fp = [genC tee]; // expected-error{{incompatible pointer types assigning to 'float *' from 'C *'}}
+  fp = [genC maybeTee]; // expected-error{{incompatible pointer types assigning to 'float *' from 'C * _Nullable'}}
 
   Generic_with_C genC2;
-  fp = genC2; // expected-error{{from incompatible type 'Generic_with_C' (aka 'NSGeneric<C *> *')}}
+  fp = genC2; // expected-error{{incompatible pointer types assigning to 'float *' from 'Generic_with_C' (aka 'NSGeneric<C *> *')}}
 }

clang/test/SemaObjCXX/objc-container-subscripting.mm

 // RUN: %clang_cc1 -fblocks -triple x86_64-apple-darwin11 -fsyntax-only -std=c++11 -verify %s
 
 @class NSArray;
 
 @interface NSMutableDictionary
 - (id)objectForKeyedSubscript:(id)key;
 - (void)setObject:(id)object forKeyedSubscript:(id)key; // expected-note {{passing argument to parameter 'object' here}}
 @end
 
 template<typename T, typename U, typename O>
 void test_dictionary_subscripts(T base, U key, O obj) {
   base[key] = obj; // expected-error {{expected method to write array element not found on object of type 'NSMutableDictionary *'}} \
                    // expected-error {{cannot initialize a parameter of type 'id' with an lvalue of type 'int'}}
   obj = base[key];  // expected-error {{expected method to read array element not found on object of type 'NSMutableDictionary *'}} \
-                    // expected-error {{assigning to 'int' from incompatible type 'id'}}
+                    // expected-error {{incompatible pointer to integer conversion assigning to 'int' from 'id'}}
      
 }
 
 template void test_dictionary_subscripts(NSMutableDictionary*, id, NSArray *ns);
 
 template void test_dictionary_subscripts(NSMutableDictionary*, NSArray *ns, id);
 
 template void test_dictionary_subscripts(NSMutableDictionary*, int, id); // expected-note {{in instantiation of function template specialization 'test_dictionary_subscripts<NSMutableDictionary *, int, id>' requested here}}

clang/test/SemaObjCXX/parameterized_classes_subst.mm

void test_message_send_result(
        UntypedMutableSet *untypedMutSet,
        MutableSetOfArrays<NSString *> *mutStringArraySet,
        NSSet *set,
        NSMutableSet *mutSet,
        MutableSetOfArrays *mutArraySet,
        NSArray<NSString *> *stringArray,
        void (^block)(void)) {
   int *ip;
-  ip = [stringSet firstObject]; // expected-error{{from incompatible type 'NSString *'}}
-  ip = [mutStringSet firstObject]; // expected-error{{from incompatible type 'NSString *'}}
-  ip = [widgetSet firstObject]; // expected-error{{from incompatible type 'Widget *'}}
-  ip = [untypedMutSet firstObject]; // expected-error{{from incompatible type 'id'}}
-  ip = [mutStringArraySet firstObject]; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = [set firstObject]; // expected-error{{from incompatible type 'id'}}
-  ip = [mutSet firstObject]; // expected-error{{from incompatible type 'id'}}
-  ip = [mutArraySet firstObject]; // expected-error{{from incompatible type 'id'}}
-  ip = [block firstObject]; // expected-error{{from incompatible type 'id'}}
+  ip = [stringSet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
+  ip = [mutStringSet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
+  ip = [widgetSet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'Widget *'}}
+  ip = [untypedMutSet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
+  ip = [mutStringArraySet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = [set firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
+  ip = [mutSet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
+  ip = [mutArraySet firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
+  ip = [block firstObject]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
 
-  ip = [stringSet findObject:@"blah"]; // expected-error{{from incompatible type 'NSString *'}}
+  ip = [stringSet findObject:@"blah"]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
 
   // Class messages.
-  ip = [NSSet<NSString *> alloc]; // expected-error{{from incompatible type 'NSSet<NSString *> *'}}
-  ip = [NSSet alloc]; // expected-error{{from incompatible type 'NSSet *'}}
-  ip = [MutableSetOfArrays<NSString *> alloc]; // expected-error{{from incompatible type 'MutableSetOfArrays<NSString *> *'}}
-  ip = [MutableSetOfArrays alloc];  // expected-error{{from incompatible type 'MutableSetOfArrays *'}}
-  ip = [NSArray<NSString *> array]; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = [NSArray<NSString *><NSCopying> array]; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
+  ip = [NSSet<NSString *> alloc]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSSet<NSString *> *'}}
+  ip = [NSSet alloc]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSSet *'}}
+  ip = [MutableSetOfArrays<NSString *> alloc]; // expected-error{{incompatible pointer types assigning to 'int *' from 'MutableSetOfArrays<NSString *> *'}}
+  ip = [MutableSetOfArrays alloc];  // expected-error{{incompatible pointer types assigning to 'int *' from 'MutableSetOfArrays *'}}
+  ip = [NSArray<NSString *> array]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = [NSArray<NSString *><NSCopying> array]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
 
-  ip = [[NSMutableArray<NSString *> alloc] init];  // expected-error{{from incompatible type 'NSMutableArray<NSString *> *'}}
+  ip = [[NSMutableArray<NSString *> alloc] init];  // expected-error{{incompatible pointer types assigning to 'int *' from 'NSMutableArray<NSString *> *'}}
 
   [[NSMutableArray alloc] initWithArray: stringArray]; // okay
   [[NSMutableArray<NSString *> alloc] initWithArray: stringArray]; // okay
   [[NSMutableArray<NSNumber *> alloc] initWithArray: stringArray]; // expected-error{{parameter of type 'NSArray<NSNumber *> *' with an lvalue of type 'NSArray<NSString *> *'}}
 }
 
 void test_message_send_param(
        NSMutableSet<NSString *> *mutStringSet,
void test_property_read(
        WidgetSet *widgetSet,
        UntypedMutableSet *untypedMutSet,
        MutableSetOfArrays<NSString *> *mutStringArraySet,
        NSSet *set,
        NSMutableSet *mutSet,
        MutableSetOfArrays *mutArraySet,
        NSMutableDictionary *mutDict) {
   int *ip;
-  ip = stringSet.allObjects; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = mutStringSet.allObjects; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = widgetSet.allObjects; // expected-error{{from incompatible type 'NSArray<Widget *> *'}}
-  ip = untypedMutSet.allObjects; // expected-error{{from incompatible type 'NSArray *'}}
-  ip = mutStringArraySet.allObjects; // expected-error{{from incompatible type 'NSArray<NSArray<NSString *> *> *'}}
-  ip = set.allObjects; // expected-error{{from incompatible type 'NSArray *'}}
-  ip = mutSet.allObjects; // expected-error{{from incompatible type 'NSArray *'}}
-  ip = mutArraySet.allObjects; // expected-error{{from incompatible type 'NSArray *'}}
+  ip = stringSet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = mutStringSet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = widgetSet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<Widget *> *'}}
+  ip = untypedMutSet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
+  ip = mutStringArraySet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSArray<NSString *> *> *'}}
+  ip = set.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
+  ip = mutSet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
+  ip = mutArraySet.allObjects; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
 
-  ip = mutDict.someRandomKey; // expected-error{{from incompatible type '__kindof id<NSCopying>'}}
+  ip = mutDict.someRandomKey; // expected-error{{incompatible pointer types assigning to 'int *' from '__kindof id<NSCopying>'}}
 }
 
 void test_property_write(
        NSMutableSet<NSString *> *mutStringSet,
        WidgetSet *widgetSet,
        UntypedMutableSet *untypedMutSet,
        MutableSetOfArrays<NSString *> *mutStringArraySet,
        NSMutableSet *mutSet,
void test_subscripting(
        NSMutableDictionary<NSString *, Widget *> *mutStringWidgetDict,
        NSDictionary *dict,
        NSMutableDictionary *mutDict) {
   int *ip;
   NSString *string;
   Widget *widget;
   Window *window;
 
-  ip = stringArray[0]; // expected-error{{from incompatible type 'NSString *'}}
+  ip = stringArray[0]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
 
-  ip = mutStringArray[0]; // expected-error{{from incompatible type 'NSString *'}}
+  ip = mutStringArray[0]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
   mutStringArray[0] = ip; // expected-error{{parameter of type 'NSString *'}}
 
-  ip = array[0]; // expected-error{{from incompatible type 'id'}}
+  ip = array[0]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
 
-  ip = mutArray[0]; // expected-error{{from incompatible type 'id'}}
+  ip = mutArray[0]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
   mutArray[0] = ip; // expected-error{{parameter of type 'id'}}
 
-  ip = stringWidgetDict[string]; // expected-error{{from incompatible type 'Widget *'}}
+  ip = stringWidgetDict[string]; // expected-error{{incompatible pointer types assigning to 'int *' from 'Widget *'}}
   widget = stringWidgetDict[widget]; // expected-error{{parameter of type 'NSString *'}}
 
-  ip = mutStringWidgetDict[string]; // expected-error{{from incompatible type 'Widget *'}}
+  ip = mutStringWidgetDict[string]; // expected-error{{incompatible pointer types assigning to 'int *' from 'Widget *'}}
   widget = mutStringWidgetDict[widget]; // expected-error{{parameter of type 'NSString *'}}
   mutStringWidgetDict[string] = ip; // expected-error{{parameter of type 'Widget *'}}
   mutStringWidgetDict[widget] = widget; // expected-error{{parameter of type 'NSString *'}}
 
-  ip = dict[string]; // expected-error{{from incompatible type 'id'}}
+  ip = dict[string]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
 
-  ip = mutDict[string]; // expected-error{{incompatible type 'id'}}
+  ip = mutDict[string]; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
   mutDict[string] = ip; // expected-error{{parameter of type 'id'}}
 
   widget = mutDict[window];
   mutDict[window] = widget; // expected-error{{parameter of type 'id<NSCopying>'}}
 }
 
 // --------------------------------------------------------------------------
 // Instance variable access.
 // --------------------------------------------------------------------------
 void test_instance_variable(NSArray<NSString *> *stringArray,
                             NSArray *array) {
   int *ip;
 
-  ip = stringArray->data; // expected-error{{from incompatible type 'NSString **'}}
-  ip = array->data; // expected-error{{from incompatible type 'id *'}}
+  ip = stringArray->data; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString **'}}
+  ip = array->data; // expected-error{{incompatible pointer types assigning to 'int *' from 'id *'}}
 }
 
 @implementation WindowArray
 - (void)testInstanceVariable {
   int *ip;
 
-  ip = data; // expected-error{{from incompatible type 'Window **'}}
+  ip = data; // expected-error{{incompatible pointer types assigning to 'int *' from 'Window **'}}
 }
 @end
 
 // --------------------------------------------------------------------------
 // Implicit conversions.
 // --------------------------------------------------------------------------
 void test_implicit_conversions(NSArray<NSString *> *stringArray,
                                NSArray<NSNumber *> *numberArray,
                                NSMutableArray<NSString *> *mutStringArray,
                                NSArray *array,
                                NSMutableArray *mutArray) {
   // Specialized -> unspecialized (same level)
   array = stringArray;
 
   // Unspecialized -> specialized (same level)
   stringArray = array;
 
   // Specialized -> specialized failure (same level).
-  stringArray = numberArray; // expected-error{{assigning to 'NSArray<NSString *> *' from incompatible type 'NSArray<NSNumber *> *'}}
+  stringArray = numberArray; // expected-error{{incompatible pointer types assigning to 'NSArray<NSString *> *' from 'NSArray<NSNumber *> *'}}
 
   // Specialized -> specialized (different levels).
   stringArray = mutStringArray;
 
   // Specialized -> specialized failure (different levels).
-  numberArray = mutStringArray; // expected-error{{assigning to 'NSArray<NSNumber *> *' from incompatible type 'NSMutableArray<NSString *> *'}}
+  numberArray = mutStringArray; // expected-error{{incompatible pointer types assigning to 'NSArray<NSNumber *> *' from 'NSMutableArray<NSString *> *'}}
 
   // Unspecialized -> specialized (different levels).
   stringArray = mutArray;
 
   // Specialized -> unspecialized (different levels).
   array = mutStringArray;
 }
 
void test_ternary_operator(NSArray<NSString *> *stringArray,
                            NSMutableArray<NSString *> *mutStringArray,
                            NSStringArray *stringArray2,
                            NSArray *array,
                            NSMutableArray *mutArray,
                            int cond) {
   int *ip;
   id object;
 
-  ip = cond ? stringArray : mutStringArray; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = cond ? mutStringArray : stringArray; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
+  ip = cond ? stringArray : mutStringArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = cond ? mutStringArray : stringArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
 
-  ip = cond ? stringArray2 : mutStringArray; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = cond ? mutStringArray : stringArray2; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
+  ip = cond ? stringArray2 : mutStringArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = cond ? mutStringArray : stringArray2; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
 
-  ip = cond ? stringArray : mutArray; // expected-error{{from incompatible type 'NSArray *'}}
+  ip = cond ? stringArray : mutArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
 
-  ip = cond ? stringArray2 : mutArray; // expected-error{{from incompatible type 'NSArray *'}}
+  ip = cond ? stringArray2 : mutArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
 
-  ip = cond ? mutArray : stringArray; // expected-error{{from incompatible type 'NSArray *'}}
+  ip = cond ? mutArray : stringArray; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
 
-  ip = cond ? mutArray : stringArray2; // expected-error{{from incompatible type 'NSArray *'}}
+  ip = cond ? mutArray : stringArray2; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray *'}}
 
   object = cond ? stringArray : numberArray; // expected-warning{{incompatible operand types ('NSArray<NSString *> *' and 'NSArray<NSNumber *> *')}}
 }
 
 // --------------------------------------------------------------------------
 // super
 // --------------------------------------------------------------------------
 @implementation NSStringArray
 - (void)useSuperMethod {
   int *ip;
-  ip = super.lastObject; // expected-error{{from incompatible type 'NSString *'}}
-  ip = [super objectAtIndexedSubscript:0]; // expected-error{{from incompatible type 'NSString *'}}
+  ip = super.lastObject; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
+  ip = [super objectAtIndexedSubscript:0]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSString *'}}
 }
 
 + (void)useSuperMethod {
   int *ip;
-  ip = super.array; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
-  ip = [super array]; // expected-error{{from incompatible type 'NSArray<NSString *> *'}}
+  ip = super.array; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
+  ip = [super array]; // expected-error{{incompatible pointer types assigning to 'int *' from 'NSArray<NSString *> *'}}
 }
 @end
 
 // --------------------------------------------------------------------------
 // Template instantiation
 // --------------------------------------------------------------------------
 template<typename K, typename V>
 struct NSMutableDictionaryOf {

clang/test/SemaObjCXX/property-invalid-type.mm

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
 
 @interface I
 {
   A* response; // expected-error {{unknown type name 'A'}}
 }
 @end
 @interface I ()
 @property A* response;  // expected-error {{unknown type name 'A'}}
 @property  int helper;
 @end
 @implementation I
 @synthesize response;
 - (void) foo :(A*) a   // expected-error {{expected a type}}
 {
-  self.response = a; // expected-error{{assigning to 'int *' from incompatible type 'id'}}
+  self.response = a; // expected-error{{incompatible pointer types assigning to 'int *' from 'id'}}
 }
 @end
 
 void foo(I *i)
 {
   i.helper; // expected-warning{{property access result unused - getters should not be used for side effects}}
 }

clang/test/SemaOpenCL/address-spaces-conversions-cl2.0.cl

 #endif
 
   AS int *var_impl;
   var_impl = arg_glob;
 #ifdef CONSTANT
 #if !__OPENCL_CPP_VERSION__
 // expected-error@-3{{assigning '__global int *__private' to '__constant int *__private' changes address space of pointer}}
 #else
-// expected-error@-5{{assigning to '__constant int *' from incompatible type '__global int *__private'}}
+// expected-error@-5{{assigning '__global int *__private' to '__constant int *' changes address space of pointer}}
 #endif
 #endif
 
   var_impl = arg_loc;
 #ifndef GENERIC
 #if !__OPENCL_CPP_VERSION__
 // expected-error-re@-3{{assigning '__local int *__private' to '__{{global|constant}} int *__private' changes address space of pointer}}
 #else
-// expected-error-re@-5{{assigning to '__{{global|constant}} int *' from incompatible type '__local int *__private'}}
+// expected-error-re@-5{{assigning '__local int *__private' to '__{{global|constant}} int *' changes address space of pointer}}
 #endif
 #endif
 
   var_impl = arg_const;
 #ifndef CONSTANT
 #if !__OPENCL_CPP_VERSION__
 // expected-error-re@-3{{assigning '__constant int *__private' to '__{{global|generic}} int *__private' changes address space of pointer}}
 #else
-// expected-error-re@-5{{assigning to '__{{global|generic}} int *' from incompatible type '__constant int *__private'}}
+// expected-error-re@-5{{assigning '__constant int *__private' to '__{{global|generic}} int *' changes address space of pointer}}
 #endif
 #endif
 
   var_impl = arg_priv;
 #ifndef GENERIC
 #if !__OPENCL_CPP_VERSION__
 // expected-error-re@-3{{assigning '__private int *__private' to '__{{global|constant}} int *__private' changes address space of pointer}}
 #else
-// expected-error-re@-5{{assigning to '__{{global|constant}} int *' from incompatible type '__private int *__private'}}
+// expected-error-re@-5{{assigning '__private int *__private' to '__{{global|constant}} int *' changes address space of pointer}}
 #endif
 #endif
 
   var_impl = arg_gen;
 #ifndef GENERIC
 #if !__OPENCL_CPP_VERSION__
 // expected-error-re@-3{{assigning '__generic int *__private' to '__{{global|constant}} int *__private' changes address space of pointer}}
 #else
-// expected-error-re@-5{{assigning to '__{{global|constant}} int *' from incompatible type '__generic int *__private'}}
+// expected-error-re@-5{{assigning '__generic int *__private' to '__{{global|constant}} int *' changes address space of pointer}}
 #endif
 #endif
 
   var_cast1 = (AS int *)arg_glob;
 #ifdef CONSTANT
 #if !__OPENCL_CPP_VERSION__
 // expected-error@-3{{casting '__global int *' to type '__constant int *' changes address space of pointer}}
 #else

 #endif
 
   // Case 3: Corresponded inner pointees has overlapping but not equivalent address spaces.
   var_as_as_int = var_asc_asc_int;
 #ifdef GENERIC
 #if !__OPENCL_CPP_VERSION__
 // expected-error@-3 {{assigning '__local int *__local *__private' to '__generic int *__generic *__private' changes address space of nested pointer}}
 #else
-// expected-error@-5 {{assigning to '__generic int *__generic *' from incompatible type '__local int *__local *__private'}}
+// expected-error@-5 {{assigning '__local int *__local *__private' to '__generic int *__generic *' changes address space of nested pointer}}
 #endif
 #endif
 
   var_as_as_int = (AS int *AS *)var_asc_asc_int;
 #ifdef GENERIC
 #if !__OPENCL_CPP_VERSION__
 // expected-warning@-3 {{casting '__local int *__local *' to type '__generic int *__generic *' discards qualifiers in nested pointer types}}
 #else

clang/test/SemaOpenCL/address-spaces.cl

#if ((!__OPENCL_CPP_VERSION__) && (__OPENCL_C_VERSION__ < 200))
   ip = &ci; // expected-error {{assigning '__constant int *' to '__private int *__private' changes address space of pointer}}
 #else
   ip = gip;
   ip = &li;
   ip = &ci;
 #if !__OPENCL_CPP_VERSION__
 // expected-error@-2 {{assigning '__constant int *' to '__generic int *__private' changes address space of pointer}}
 #else
-// expected-error@-4 {{assigning to '__generic int *' from incompatible type '__constant int *'}}
+// expected-error@-4 {{assigning '__constant int *' to '__generic int *' changes address space of pointer}}
 #endif
 #endif
 }
 
 void explicit_cast(__global int *g, __local int *l, __constant int *c, __private int *p, const __constant int *cc) {
   g = (__global int *)l;
 #if !__OPENCL_CPP_VERSION__
 // expected-error@-2 {{casting '__local int *' to type '__global int *' changes address space of pointer}}
void nested(__global int *g, __global int * __private *gg, __local int *l, __local int * __private *ll, __global float * __private *gg_f) {
   pg = pl;  // expected-error {{assigning '__private l_t *__private' (aka '__local int *__private *__private') to '__private g_t *__private' (aka '__global int *__private *__private') changes address space of nested pointer}}
   pl = pg;  // expected-error {{assigning '__private g_t *__private' (aka '__global int *__private *__private') to '__private l_t *__private' (aka '__local int *__private *__private') changes address space of nested pointer}}
 
   ll = (__local int * __private *)(void *)gg;
   void *vp = ll;
 }
 #else
 void nested(__global int *g, __global int * __private *gg, __local int *l, __local int * __private *ll, __global float * __private *gg_f) {
-  g = gg;    // expected-error {{assigning to '__global int *' from incompatible type '__global int *__private *__private'}}
-  g = l;     // expected-error {{assigning to '__global int *' from incompatible type '__local int *__private'}}
-  g = ll;    // expected-error {{assigning to '__global int *' from incompatible type '__local int *__private *__private'}}
-  g = gg_f;  // expected-error {{assigning to '__global int *' from incompatible type '__global float *__private *__private'}}
+  g = gg;    // expected-error {{assigning '__global int *__private *__private' to '__global int *' changes address space of pointer}}
+  g = l;     // expected-error {{assigning '__local int *__private' to '__global int *' changes address space of pointer}}
+  g = ll;    // expected-error {{assigning '__local int *__private *__private' to '__global int *' changes address space of pointer}}
+  g = gg_f;  // expected-error {{assigning '__global float *__private *__private' to '__global int *' changes address space of pointer}}
   g = (__global int *)gg_f; // expected-error {{C-style cast from '__global float *__private *' to '__global int *' converts between mismatching address spaces}}
 
-  gg = g;    // expected-error {{assigning to '__global int *__private *' from incompatible type '__global int *__private'; take the address with &}}
-  gg = l;    // expected-error {{assigning to '__global int *__private *' from incompatible type '__local int *__private'}}
-  gg = ll;   // expected-error {{assigning to '__global int *__private *' from incompatible type '__local int *__private *__private'}}
-  gg = gg_f; // expected-error {{assigning to '__global int *__private *' from incompatible type '__global float *__private *__private'}}
+  gg = g;    // expected-error {{assigning '__global int *__private' to '__global int *__private *' changes address space of pointer}}
+  gg = l;    // expected-error {{assigning '__local int *__private' to '__global int *__private *' changes address space of pointer}}
+  gg = ll;   // expected-error {{assigning '__local int *__private *__private' to '__global int *__private *' changes address space of nested pointer}}
+  gg = gg_f; // expected-error {{incompatible pointer types assigning to '__global int *__private *' from '__global float *__private *__private'}}
   gg = (__global int * __private *)gg_f;
 
-  l = g;     // expected-error {{assigning to '__local int *' from incompatible type '__global int *__private'}}
-  l = gg;    // expected-error {{assigning to '__local int *' from incompatible type '__global int *__private *__private'}}
-  l = ll;    // expected-error {{assigning to '__local int *' from incompatible type '__local int *__private *__private'}}
-  l = gg_f;  // expected-error {{assigning to '__local int *' from incompatible type '__global float *__private *__private'}}
+  l = g;     // expected-error {{assigning '__global int *__private' to '__local int *' changes address space of pointer}}
+  l = gg;    // expected-error {{assigning '__global int *__private *__private' to '__local int *' changes address space of pointer}}
+  l = ll;    // expected-error {{assigning '__local int *__private *__private' to '__local int *' changes address space of pointer}}
+  l = gg_f;  // expected-error {{assigning '__global float *__private *__private' to '__local int *' changes address space of pointer}}
   l = (__local int *)gg_f; // expected-error {{C-style cast from '__global float *__private *' to '__local int *' converts between mismatching address spaces}}
 
-  ll = g;    // expected-error {{assigning to '__local int *__private *' from incompatible type '__global int *__private'}}
-  ll = gg;   // expected-error {{assigning to '__local int *__private *' from incompatible type '__global int *__private *__private'}}
-  ll = l;    // expected-error {{assigning to '__local int *__private *' from incompatible type '__local int *__private'; take the address with &}}
-  ll = gg_f; // expected-error {{assigning to '__local int *__private *' from incompatible type '__global float *__private *__private'}}
+  ll = g;    // expected-error {{assigning '__global int *__private' to '__local int *__private *' changes address space of pointer}}
+  ll = gg;   // expected-error {{assigning '__global int *__private *__private' to '__local int *__private *' changes address space of nested pointer}}
+  ll = l;    // expected-error {{assigning '__local int *__private' to '__local int *__private *' changes address space of pointer}}
+  ll = gg_f; // expected-error {{assigning '__global float *__private *__private' to '__local int *__private *' changes address space of nested pointer}}
   ll = (__local int *__private *)gg; //expected-warning{{C-style cast from '__global int *__private *' to '__local int *__private *' changes address space of nested pointers}}
 
-  gg_f = g;  // expected-error {{assigning to '__global float *__private *' from incompatible type '__global int *__private'}}
-  gg_f = gg; // expected-error {{assigning to '__global float *__private *' from incompatible type '__global int *__private *__private'}}
-  gg_f = l;  // expected-error {{assigning to '__global float *__private *' from incompatible type '__local int *__private'}}
-  gg_f = ll; // expected-error {{assigning to '__global float *__private *' from incompatible type '__local int *__private *__private'}}
+  gg_f = g;  // expected-error {{assigning '__global int *__private' to '__global float *__private *' changes address space of pointer}}
+  gg_f = gg; // expected-error {{incompatible pointer types assigning to '__global float *__private *' from '__global int *__private *__private'}}
+  gg_f = l;  // expected-error {{assigning '__local int *__private' to '__global float *__private *' changes address space of pointer}}
+  gg_f = ll; // expected-error {{assigning '__local int *__private *__private' to '__global float *__private *' changes address space of nested pointer}}
   gg_f = (__global float * __private *)gg;
 
   typedef __local int * l_t;
   typedef __global int * g_t;
   __private l_t * pl;
   __private g_t * pg;
-  gg = pl;  // expected-error {{assigning to '__global int *__private *' from incompatible type '__private l_t *__private' (aka '__local int *__private *__private')}}
-  pl = gg;  // expected-error {{assigning to '__private l_t *' (aka '__local int *__private *') from incompatible type '__global int *__private *__private'}}
+  gg = pl;  // expected-error {{assigning '__private l_t *__private' (aka '__local int *__private *__private') to '__global int *__private *' changes address space of nested pointer}}
+  pl = gg;  // expected-error {{assigning '__global int *__private *__private' to '__private l_t *' (aka '__local int *__private *') changes address space of nested pointer}}
   gg = pg;
   pg = gg;
-  pg = pl;  // expected-error {{assigning to '__private g_t *' (aka '__global int *__private *') from incompatible type '__private l_t *__private' (aka '__local int *__private *__private')}}
-  pl = pg;  // expected-error {{assigning to '__private l_t *' (aka '__local int *__private *') from incompatible type '__private g_t *__private' (aka '__global int *__private *__private')}}
+  pg = pl;  // expected-error {{assigning '__private l_t *__private' (aka '__local int *__private *__private') to '__private g_t *' (aka '__global int *__private *') changes address space of nested pointer}}
+  pl = pg;  // expected-error {{assigning '__private g_t *__private' (aka '__global int *__private *__private') to '__private l_t *' (aka '__local int *__private *') changes address space of nested pointer}}
 
   ll = (__local int * __private *)(void *)gg;
   void *vp = ll;
 }
 #endif
 
 __private int func_return_priv(void);       //expected-error {{return value cannot be qualified with address space}}
 __global int func_return_global(void);      //expected-error {{return value cannot be qualified with address space}}

clang/test/SemaTemplate/extern-templates.cpp

 
 extern template class X0<int>;
 
 extern template class X0<int*>;
 
 template<typename T>
 void X0<T>::Inner::g(T t) {
 #ifdef MS
-  t = 17; // expected-error{{assigning to 'long *' from incompatible}} expected-error{{assigning to 'int *' from incompatible}}
+  t = 17; // expected-error{{incompatible integer to pointer conversion assigning to 'long *'}} expected-error{{incompatible integer to pointer conversion assigning to 'int *'}}
 #else
-  t = 17; // expected-error{{assigning to 'long *' from incompatible}}
+  t = 17; // expected-error{{incompatible integer to pointer conversion assigning to 'long *'}}
 #endif
 }
 
 void test_intptr(X0<int*> xi, X0<int*>::Inner xii) {
   xi.f(0);
 #ifdef MS
   xii.g(0); // expected-note {{instantiation}}
 #else

clang/test/SemaTemplate/instantiate-member-class.cpp

 
 X<int>::C *c1;
 X<float>::C *c2;
 
 X<int>::X *xi; // expected-error{{qualified reference to 'X' is a constructor name rather than a type}}
 X<float>::X *xf; // expected-error{{qualified reference to 'X' is a constructor name rather than a type}}
 
 void test_naming() {
-  c1 = c2; // expected-error{{assigning to 'X<int>::C *' from incompatible type 'X<float>::C *'}}
-  xi = xf;  // expected-error{{assigning to 'X<int>::X<int> *' from incompatible type 'X<float>::X<float> *'}}
+  c1 = c2; // expected-error{{incompatible pointer types assigning to 'X<int>::C *' from 'X<float>::C *'}}
+  xi = xf;  // expected-error{{incompatible pointer types assigning to 'X<int>::X<int> *' from 'X<float>::X<float> *'}}
     // FIXME: error above doesn't print the type X<int>::X cleanly!
 }
 
 void test_instantiation(X<double>::C *x,
                         X<float>::D::E *e,
                         X<float>::D::F *f) {
   double &dr = x->foo();
   float &fr = e->bar();

clang/test/SemaTemplate/member-access-expr.cpp

namespace test6 {
   struct A {};
   struct B {};
   template <class T> class Base;
   template <class T> class Derived : public Base<T> {
     A *field;
     void get(B **ptr) {
       // It's okay if at some point we figure out how to diagnose this
       // at instantiation time.
-      *ptr = field; // expected-error {{assigning to 'test6::B *' from incompatible type 'test6::A *}}
+      *ptr = field; // expected-error {{incompatible pointer types assigning to 'test6::B *' from 'test6::A *'}}
     }
   };
 }

clang/test/SemaTemplate/temp_arg_nontype.cpp

 // Check that we instantiate declarations whose addresses are taken
 // for non-type template arguments.
 namespace EntityReferenced {
   template<typename T, void (*)(T)> struct X { };
 
   template<typename T>
   struct Y {
     static void f(T x) { 
-      x = 1; // expected-error{{assigning to 'int *' from incompatible type 'int'}}
+      x = 1; // expected-error{{incompatible integer to pointer conversion assigning to 'int *' from 'int'}}
     }
   };
 
   void g() {
     typedef X<int*, Y<int*>::f> x; // expected-note{{in instantiation of}}
   }
 }