[C] Strengthen -Wint-conversion to default to an error

[aaron.ballman]

Summary

Clang has traditionally allowed C programs to implicitly convert integers to pointers and pointers to integers, despite it not being valid to do so except under special circumstances (like converting the integer 0, which is the null pointer constant, to a pointer). In C89, this would result in undefined behavior per 3.3.4, and in C99 this rule was strengthened to be a constraint violation instead. Constraint violations are most often handled as an error.

This patch changes the warning to default to an error in all C modes (it is already an error in C++). This gives us better security posture by calling out potential programmer mistakes in code but still allows users who need this behavior to use -Wno-error=int-conversion to retain the warning behavior, or -Wno-int-conversion to silence the diagnostic entirely.

When modifying the diagnostics, I observed that ext_typecheck_convert_int_pointer was already marked SFINAEFailure but ext_typecheck_convert_pointer_int was not. This appeared to be an oversight which I corrected. That resulted in needing a change to not perform SFINAE traps in C mode. If desired, I can split those changes into a separate review, but they felt related enough to this change to be reasonable to roll in here by virtue of changing the behavior of the diagnostic.

[erichkeane]

This seems like a good idea despite the breaking change. I dont see anything in the code to be concerned about, but I'm hoping others will comment as to whether this is completely acceptable.

clang/lib/Sema/SemaExprCXX.cpp

8482 ↗

(On Diff #445048)

This makes sense to me, I don't see why this hasn't bit us before, but SFINAE in C mode seems wrong?

[efriedma]

Given this is an on-by-default warning already, I don't expect changing it to an error by default to have much impact in practice. Changing it fine.

clang/lib/Sema/SemaExprCXX.cpp

8483 ↗

(On Diff #445048)

I'd prefer not to introduce unnecessary differences in C vs. C++ handling like this...

This seems weird for two reasons:

• We don't use ext_typecheck_convert_pointer_int in C++, so there's not really any reason to mark it SFINAEFailure
• Whatever code is calling this probably doesn't want an SFINAE context. Is this coming from TransformToPotentiallyEvaluated? We don't want SFINAE traps from there, in C or C++.

[aaron.ballman]

clang/lib/Sema/SemaExprCXX.cpp

8483 ↗

(On Diff #445048)

We don't use ext_typecheck_convert_pointer_int in C++, so there's not really any reason to mark it SFINAEFailure

The original changes came from: https://github.com/llvm/llvm-project/issues/39709 but I see now that we used to treat this as a warning in C++ rather than an error. So adding SFINAEFailure made sense at that point, but I think you're right that it should be removed now. I'll try that locally and see if anything explodes as a result.

Whatever code is calling this probably doesn't want an SFINAE context. Is this coming from TransformToPotentiallyEvaluated? We don't want SFINAE traps from there, in C or C++.

Typo correction went haywire. Specifically: https://github.com/llvm/llvm-project/blob/main/clang/test/Sema/typo-correction-ambiguity.c#L13

We would typo correct v_231 to be v_2_0 here, and when deciding whether that was valid or not, we'd hit the SFINAE trap in C code and that changed the behavior of the test to add suggestions instead of silence them.

I think it's incredibly weird to ever use SFINAE in C, even by accident.

[aaron.ballman]

Removed the SFINAEFailure and trap changes, added a release note.

clang/lib/Sema/SemaExprCXX.cpp

8483 ↗

(On Diff #445048)

I'll try that locally and see if anything explodes as a result.

All my local tests passed, so I've made the change and we'll see if precommit CI finds anything I didn't.

[aaron.ballman]

Ping

[efriedma]

LGTM

[augusto2112]

Hi @aaron.ballman, it looks like this broke 2 tests in the lldb test suite (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/45560/). Can we revert this to keep CI green?

[augusto2112]

Actually, never mind, I think I can fix the tests.

[aaron.ballman]

In D129881#3674159, @augusto2112 wrote:

Actually, never mind, I think I can fix the tests.

Thank you for the fix, and sorry for the trouble!

In D129881#3674157, @augusto2112 wrote:

Hi @aaron.ballman, it looks like this broke 2 tests in the lldb test suite (https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/45560/). Can we revert this to keep CI green?

FWIW, this is not a situation where I think a revert would be reasonable. Clang changed in a standards conforming way; if lldb is sensitive to a change in diagnostics like that, I believe the lldb maintainers should be addressing the situation, not the Clang maintainers. However, we of course should collaborate and not cause headaches for one another, so if it was a highly disruptive conforming change or we made a nonconforming change, that's a different story. Thank you for asking about the revert, but thank you even more for helping to fix forward (this helps us keep git blame useful without having to wade through churn commits, too)!

clang-tools-extra/test/clang-tidy/checkers/bugprone/no-escape.m

-// RUN: %check_clang_tidy %s bugprone-no-escape %t
-// RUN: %check_clang_tidy %s -assume-filename=bugprone-no-escape.c bugprone-no-escape %t -- -- -fblocks
+// RUN: %check_clang_tidy %s bugprone-no-escape %t -- -- -Wno-int-conversion
+// RUN: %check_clang_tidy %s -assume-filename=bugprone-no-escape.c bugprone-no-escape %t -- -- -fblocks -Wno-int-conversion
 
 typedef struct dispatch_queue_s *dispatch_queue_t;
 typedef struct dispatch_time_s *dispatch_time_t;
 typedef void (^dispatch_block_t)(void);
 void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
 void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);
 
 extern dispatch_queue_t queue;

clang-tools-extra/test/clang-tidy/checkers/performance/no-int-to-ptr.c

-// RUN: %check_clang_tidy %s performance-no-int-to-ptr %t
+// RUN: %check_clang_tidy %s performance-no-int-to-ptr %t -- -- -Wno-int-conversion
 
 void *t0(char x) {
   return x;
   // CHECK-MESSAGES: [[@LINE-1]]:10: warning: integer to pointer cast pessimizes optimization opportunities [performance-no-int-to-ptr]
 }
 void *t1(signed char x) {
   return x;
   // CHECK-MESSAGES: [[@LINE-1]]:10: warning: integer to pointer cast pessimizes optimization opportunities [performance-no-int-to-ptr]

clang/bindings/python/tests/cindex/test_diagnostics.py

def test_diagnostic_warning(self):
         self.assertEqual(tu.diagnostics[0].location.column, 11)
         self.assertEqual(tu.diagnostics[0].spelling,
                 'non-void function does not return a value')
 
     def test_diagnostic_note(self):
         # FIXME: We aren't getting notes here for some reason.
         tu = get_tu('#define A x\nvoid *A = 1;\n')
         self.assertEqual(len(tu.diagnostics), 1)
-        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Error)
         self.assertEqual(tu.diagnostics[0].location.line, 2)
         self.assertEqual(tu.diagnostics[0].location.column, 7)
         self.assertIn('incompatible', tu.diagnostics[0].spelling)
 #       self.assertEqual(tu.diagnostics[1].severity, Diagnostic.Note)
 #       self.assertEqual(tu.diagnostics[1].location.line, 1)
 #       self.assertEqual(tu.diagnostics[1].location.column, 11)
 #       self.assertEqual(tu.diagnostics[1].spelling, 'instantiated from')
 
def test_diagnostic_fixit(self):
         self.assertEqual(tu.diagnostics[0].fixits[0].range.start.column, 26)
         self.assertEqual(tu.diagnostics[0].fixits[0].range.end.line, 1)
         self.assertEqual(tu.diagnostics[0].fixits[0].range.end.column, 30)
         self.assertEqual(tu.diagnostics[0].fixits[0].value, '.f0 = ')
 
     def test_diagnostic_range(self):
         tu = get_tu('void f() { int i = "a"; }')
         self.assertEqual(len(tu.diagnostics), 1)
-        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Warning)
+        self.assertEqual(tu.diagnostics[0].severity, Diagnostic.Error)
         self.assertEqual(tu.diagnostics[0].location.line, 1)
         self.assertEqual(tu.diagnostics[0].location.column, 16)
         self.assertRegex(tu.diagnostics[0].spelling,
             'incompatible pointer to.*')
         self.assertEqual(len(tu.diagnostics[0].fixits), 0)
         self.assertEqual(len(tu.diagnostics[0].ranges), 1)
         self.assertEqual(tu.diagnostics[0].ranges[0].start.line, 1)
         self.assertEqual(tu.diagnostics[0].ranges[0].start.column, 20)

clang/docs/ReleaseNotes.rst

- The ``-Winfinite-recursion`` diagnostic no longer warns about
   unevaluated operands of a ``typeid`` expression, as they are now
   modeled correctly in the CFG. This fixes
   `Issue 21668 <https://github.com/llvm/llvm-project/issues/21668>`_.
 - ``-Wself-assign``, ``-Wself-assign-overloaded`` and ``-Wself-move`` will
   suggest a fix if the decl being assigned is a parameter that shadows a data
   member of the contained class.
 - Added ``-Winvalid-utf8`` which diagnoses invalid UTF-8 code unit sequences in
   comments.
+- The ``-Wint-conversion`` warning diagnostic for implicit int <-> pointer
+  conversions now defaults to an error in all C language modes. It may be
+  downgraded to a warning with ``-Wno-error=int-conversion``, or disabled
+  entirely with ``-Wno-int-conversion``.
+
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 
 - Improve __builtin_dump_struct:
 
   - Support bitfields in struct and union.
   - Improve the dump format, dump both bitwidth(if its a bitfield) and field

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_incompatible_qualified_id : Error<
   "|%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 ext_typecheck_convert_pointer_int : ExtWarn<
+  err_typecheck_convert_pointer_int.Text>,
+  InGroup<IntConversion>, DefaultError;
 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_int_pointer : ExtWarn<
+  err_typecheck_convert_int_pointer.Text>,
+  InGroup<IntConversion>, DefaultError;
 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 $|"

clang/test/Analysis/ObjCProperties.m

-// RUN: %clang_analyze_cc1 -w %s -verify \
+// RUN: %clang_analyze_cc1 -w -Wno-int-conversion %s -verify \
 // RUN:     -analyzer-checker=core,alpha.core,debug.ExprInspection
 
 #ifdef HEADER // A clever trick to avoid splitting up the test.
 extern void clang_analyzer_eval(int);
 
 @interface NSObject
 @end
 

clang/test/Analysis/bsd-string.c

-// RUN: %clang_analyze_cc1 -w -verify %s \
+// RUN: %clang_analyze_cc1 -w -Wno-int-conversion -verify %s \
 // RUN:   -analyzer-checker=core \
 // RUN:   -analyzer-checker=unix.cstring.NullArg \
 // RUN:   -analyzer-checker=alpha.unix.cstring \
 // RUN:   -analyzer-checker=debug.ExprInspection
 
 #define NULL ((void *)0)
 
 typedef __typeof(sizeof(int)) size_t;

clang/test/Analysis/novoidtypecrash.c

-// RUN: %clang_analyze_cc1 -std=c89 -analyzer-checker=core %s
+// RUN: %clang_analyze_cc1 -std=c89 -Wno-int-conversion -analyzer-checker=core %s
 x;
 y(void **z) { // no-crash
   *z = x;
   int *w;
   y(&w);
   *w;
 }
 

clang/test/Analysis/null-deref-ps.c

-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -Wno-strict-prototypes -Wno-tautological-constant-compare -Wtautological-unsigned-zero-compare -analyzer-checker=core,deadcode,alpha.core -std=gnu99 -analyzer-purge=none -verify %s -Wno-error=return-type
-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -Wno-strict-prototypes -Wno-tautological-constant-compare -Wtautological-unsigned-zero-compare -analyzer-checker=core,deadcode,alpha.core -std=gnu99 -verify %s -Wno-error=return-type
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -Wno-int-conversion -Wno-strict-prototypes -Wno-tautological-constant-compare -Wtautological-unsigned-zero-compare -analyzer-checker=core,deadcode,alpha.core -std=gnu99 -analyzer-purge=none -verify %s -Wno-error=return-type
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -Wno-int-conversion -Wno-strict-prototypes -Wno-tautological-constant-compare -Wtautological-unsigned-zero-compare -analyzer-checker=core,deadcode,alpha.core -std=gnu99 -verify %s -Wno-error=return-type
 
 typedef unsigned uintptr_t;
 
 extern void __assert_fail (__const char *__assertion, __const char *__file,
     unsigned int __line, __const char *__function)
      __attribute__ ((__noreturn__));
 
 #define assert(expr) \
   ((expr)  ? (void)(0)  : __assert_fail (#expr, __FILE__, __LINE__, __func__))
 
-void f1(int *p) {  
+void f1(int *p) {
   if (p) *p = 1;
   else *p = 0; // expected-warning{{ereference}}
 }
 
 struct foo_struct {
   int x;
 };
 
 int f2(struct foo_struct* p) {
-  
   if (p)
     p->x = 1;
-    
   return p->x++; // expected-warning{{Access to field 'x' results in a dereference of a null pointer (loaded from variable 'p')}}
 }
 
 int f3(char* x) {
-  
   int i = 2;
-  
   if (x)
     return x[i - 1];
-  
   return x[i+1]; // expected-warning{{Array access (from variable 'x') results in a null pointer dereference}}
 }
 
 int f3_b(char* x) {
-  
   int i = 2;
-  
   if (x)
     return x[i - 1];
-  
   return x[i+1]++; // expected-warning{{Array access (from variable 'x') results in a null pointer dereference}}
 }
 
 int f4(int *p) {
-  
   uintptr_t x = (uintptr_t) p;
-  
   if (x)
     return 1;
-    
   int *q = (int*) x;
   return *q; // expected-warning{{Dereference of null pointer (loaded from variable 'q')}}
 }
 
 int f4_b(void) {
   short array[2];
-  uintptr_t x = array; // expected-warning{{incompatible pointer to integer conversion}}
-  short *p = x; // expected-warning{{incompatible integer to pointer conversion}}
+  uintptr_t x = array;
+  short *p = x;
 
   // The following branch should be infeasible.
   if (!(p == &array[0])) {
     p = 0;
     *p = 1; // no-warning
   }
 
   if (p) {
     *p = 5; // no-warning
     p = 0;
   }
   else return; // expected-warning {{non-void function 'f4_b' should return a value}}
 
   *p += 10; // expected-warning{{Dereference of null pointer}}
   return 0;
 }
 
 int f5(void) {
-  
   char *s = "hello world";
   return s[0]; // no-warning
 }
 
 int bar(int* p, int q) __attribute__((nonnull));
 
-int f6(int *p) { 
+int f6(int *p) {
   return !p ? bar(p, 1) // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
          : bar(p, 0);   // no-warning
 }
 
 int bar2(int* p, int q) __attribute__((nonnull(1)));
 
-int f6b(int *p) { 
+int f6b(int *p) {
   return !p ? bar2(p, 1) // expected-warning {{Null pointer passed to 1st parameter expecting 'nonnull'}}
          : bar2(p, 0);   // no-warning
 }
 
 int bar3(int*p, int q, int *r) __attribute__((nonnull(1,3)));
 
 int f6c(int *p, int *q) {
    return !p ? bar3(q, 2, p) // expected-warning {{Null pointer passed to 3rd parameter expecting 'nonnull'}}
              : bar3(p, 2, q); // no-warning
 }
 
 void f6d(int *p) {
   bar(p, 0);
   // At this point, 'p' cannot be null.
   if (!p) {
     int *q = 0;
-    *q = 0xDEADBEEF; // no-warning    
-  }  
+    *q = 0xDEADBEEF; // no-warning
+  }
 }
 
 void f6e(int *p, int offset) {
   // PR7406 - crash from treating an UnknownVal as defined, to see if it's 0.
   bar((p+offset)+1, 0); // not crash
 }
 
 int* qux();
 
 int f7(int x) {
-  
   int* p = 0;
-  
   if (0 == x)
     p = qux();
-  
   if (0 == x)
     *p = 1; // no-warning
-    
   return x;
 }
 
 int* f7b(int *x) {
-  
   int* p = 0;
-  
   if (((void*)0) == x)
     p = qux();
-  
   if (((void*)0) == x)
     *p = 1; // no-warning
-    
   return x;
 }
 
 int* f7c(int *x) {
-  
   int* p = 0;
-  
   if (((void*)0) == x)
     p = qux();
-  
   if (((void*)0) != x)
     return x;
 
   // If we reach here then 'p' is not null.
   *p = 1; // no-warning
   return x;
 }
 
 int* f7c2(int *x) {
-  
   int* p = 0;
-  
   if (((void*)0) == x)
     p = qux();
-  
   if (((void*)0) == x)
     return x;
-    
   *p = 1; // expected-warning{{null}}
   return x;
 }
 
 
 void f8(int *p, int *q) {
   if (!p)
     if (p)
       *p = 1; // no-warning
-  
   if (q)
     if (!q)
       *q = 1; // no-warning
 }
 
 int* qux();
 
 int f9(unsigned len) {
int f9b(unsigned len) {
   return *p++; // no-warning
 }
 
 int* f10(int* p, signed char x, int y) {
   // This line tests symbolication with compound assignments where the
   // LHS and RHS have different bitwidths.  The new symbolic value
   // for 'x' should have a bitwidth of 8.
   x &= y;
-  
   // This tests that our symbolication worked, and that we correctly test
   // x against 0 (with the same bitwidth).
   if (!x) {
     if (!p) return 0;
     *p = 10;
   }
   else p = 0;
 
void f12(HF12ITEM i, char *q) {
   case 0 ... 10:
     p = q;
     break;
   case (DWORD_PTR) ((HF12ITEM) - 65535):
     return;
   default:
     return;
   }
-  
   *p = 1; // no-warning
 }
 
 // Test handling of translating between integer "pointers" and back.
 void f13(void) {
   int *x = 0;
   if (((((int) x) << 2) + 1) >> 1) *x = 1;
 }

clang/test/Analysis/number-object-conversion.c

-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -w -analyzer-checker=osx.NumberObjectConversion %s -verify
-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -w -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
 
 #define NULL ((void *)0)
 
 typedef const struct __CFNumber *CFNumberRef;
 
 void takes_int(int);
 
 void bad(CFNumberRef p) {

clang/test/Analysis/number-object-conversion.m

-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -w -analyzer-checker=osx.NumberObjectConversion %s -verify
-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -w -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -fobjc-arc -w -analyzer-checker=osx.NumberObjectConversion %s -verify
-// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -fobjc-arc -w -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -fobjc-arc -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion %s -verify
+// RUN: %clang_analyze_cc1 -triple i386-apple-darwin10 -fblocks -fobjc-arc -w -Wno-int-conversion -analyzer-checker=osx.NumberObjectConversion -analyzer-config osx.NumberObjectConversion:Pedantic=true -DPEDANTIC %s -verify
 
 #include "Inputs/system-header-simulator-objc.h"
 
 void takes_boolean(BOOL);
 void takes_integer(int);
 
 void bad(NSNumber *p) {
 #ifdef PEDANTIC

clang/test/Analysis/pr22954.c

 // Given code 'struct aa { char s1[4]; char * s2;} a; memcpy(a.s1, ...);',
 // this test checks that the CStringChecker only invalidates the destination buffer array a.s1 (instead of a.s1 and a.s2).
 // At the moment the whole of the destination array content is invalidated.
 // If a.s1 region has a symbolic offset, the whole region of 'a' is invalidated.
 // Specific triple set to test structures of size 0.
-// RUN: %clang_analyze_cc1 -triple x86_64-pc-linux-gnu -analyzer-checker=core,unix.Malloc,debug.ExprInspection -verify -analyzer-config eagerly-assume=false %s
+// RUN: %clang_analyze_cc1 -triple x86_64-pc-linux-gnu -analyzer-checker=core,unix.Malloc,debug.ExprInspection -Wno-error=int-conversion -verify -analyzer-config eagerly-assume=false %s
 
 typedef __typeof(sizeof(int)) size_t;
 
 char *strdup(const char *s);
 void free(void *);
 void *memcpy(void *dst, const void *src, size_t n); // expected-note{{passing argument to parameter 'dst' here}}
 void *malloc(size_t n);
 

clang/test/C/drs/dr0xx.c

  * Null pointer constants
  */
 char *dr064_1(int i, int *pi) {
   *pi = i;
   return 0;
 }
 
 char *dr064_2(int i, int *pi) {
-  return (*pi = i, 0); /* expected-warning {{incompatible integer to pointer conversion returning 'int' from a function with result type 'char *'}} */
+  return (*pi = i, 0); /* expected-error {{incompatible integer to pointer conversion returning 'int' from a function with result type 'char *'}} */
 }
 
 /* WG14 DR068: yes
  * 'char' and signed vs unsigned integer types
  */
 void dr068(void) {
   #include <limits.h>
 

clang/test/C/drs/dr2xx.c

void dr261(void) {
    * diagnostic, but the diagnostic does help demonstrate that we correctly
    * treat it as a null pointer constant value.
    */
   char *p1 = (1 - 1); /* expected-warning {{expression which evaluates to zero treated as a null pointer constant of type 'char *'}} */
 
   /* This is an invalid initialization/assignment because the right-hand side
    * does not have pointer to void or pointer to char type and is not the null
    * pointer constant. */
-  char *p2 = (42, 1 - 1); /* expected-warning {{incompatible integer to pointer conversion initializing 'char *' with an expression of type 'int'}}
+  char *p2 = (42, 1 - 1); /* expected-error {{incompatible integer to pointer conversion initializing 'char *' with an expression of type 'int'}}
                              expected-warning {{left operand of comma operator has no effect}}
                            */
-  p1 = (42, 1 - 1);       /* expected-warning {{incompatible integer to pointer conversion assigning to 'char *' from 'int'}}
+  p1 = (42, 1 - 1);       /* expected-error {{incompatible integer to pointer conversion assigning to 'char *' from 'int'}}
                              expected-warning {{left operand of comma operator has no effect}}
                            */
 
   /* These are both valid. The initialization doesn't require an integer
    * constant expression, nor does the assignment.
    */
   short s1 = 42 + (0, 1); /* c89only-warning {{mixing declarations and code is a C99 extension}}
                              expected-warning {{left operand of comma operator has no effect}}

clang/test/CodeGen/2008-03-05-syncPtr.c

-// RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers -triple x86_64-apple-darwin -Wno-int-conversion %s -emit-llvm -o - | FileCheck %s
 
 int* foo(int** a, int* b, int* c) {
 return __sync_val_compare_and_swap (a, b, c);
 }
 // CHECK-LABEL: define{{.*}} i32* @foo
 // CHECK: cmpxchg {{.*}}, align 8
 
 int foo2(int** a, int* b, int* c) {

clang/test/CodeGen/2008-07-31-promotion-of-compound-pointer-arithmetic.c

-// RUN: %clang_cc1 -triple i386-unknown-unknown -O1 -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple i386-unknown-unknown -O1 -Wno-int-conversion -emit-llvm -o - %s | FileCheck %s
 // CHECK-LABEL: define{{.*}} i32 @f0
 // CHECK:   ret i32 1
 // CHECK-LABEL: define{{.*}} i32 @f1
 // CHECK:   ret i32 1
 // CHECK-LABEL: define{{.*}} i32 @f2
 // CHECK:   ret i32 1
 // <rdr://6115726>
 

clang/test/CodeGen/aarch64-mops.c

-// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -target-feature +mops -target-feature +mte -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-MOPS   %s
-// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -target-feature +mops -Wno-implicit-function-declaration -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
-// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-implicit-function-declaration -target-feature +mte -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
-// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-implicit-function-declaration -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
+// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-int-conversion -target-feature +mops -target-feature +mte -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-MOPS   %s
+// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-int-conversion -target-feature +mops -Wno-implicit-function-declaration -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
+// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-int-conversion -Wno-implicit-function-declaration -target-feature +mte -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
+// RUN: %clang_cc1 -triple aarch64-arm-unknown-eabi -Wno-int-conversion -Wno-implicit-function-declaration -w -S -emit-llvm -o - %s  | FileCheck --check-prefix=CHECK-NOMOPS %s
 
 #include <arm_acle.h>
 #include <stddef.h>
 
 // CHECK-LABEL:       @bzero_0(
 // CHECK-MOPS:        @llvm.aarch64.mops.memset.tag
 // CHECK-NOMOPS-NOT:  @llvm.aarch64.mops.memset.tag
 void *bzero_0(void *dst) {

clang/test/CodeGen/address-space-cast.c

-// RUN: %clang_cc1 -emit-llvm < %s
+// RUN: %clang_cc1 -emit-llvm -Wno-int-conversion < %s
 
 volatile unsigned char* const __attribute__((address_space(1))) serial_ctrl = 0x02;
 

clang/test/CodeGen/const-init.c

-// RUN: %clang_cc1 -no-opaque-pointers -triple i386-pc-linux-gnu -ffreestanding -Wno-pointer-to-int-cast -verify -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers -triple i386-pc-linux-gnu -ffreestanding -Wno-pointer-to-int-cast -Wno-int-conversion -emit-llvm -o - %s | FileCheck %s
 
 #include <stdint.h>
 
 // Brace-enclosed string array initializers
 char a[] = { "asdf" };
 // CHECK: @a ={{.*}} global [5 x i8] c"asdf\00"
 
 char a2[2][5] = { "asdf" };
 // CHECK: @a2 ={{.*}} global [2 x [5 x i8]] {{\[}}[5 x i8] c"asdf\00", [5 x i8] zeroinitializer]
 
 // Double-implicit-conversions of array/functions (not legal C, but
 // clang accepts it for gcc compat).
-intptr_t b = a; // expected-warning {{incompatible pointer to integer conversion}}
+intptr_t b = a;
 int c(void);
 void *d = c;
-intptr_t e = c; // expected-warning {{incompatible pointer to integer conversion}}
+intptr_t e = c;
 
 int f, *g = __extension__ &f, *h = (1 != 1) ? &f : &f;
 
 union s2 {
   struct {
     struct { } *f0;
   } f0;
 };

 // PR5108
 // CHECK: @gv1 ={{.*}} global %struct.anon <{ i32 0, i8 7 }>, align 1
 struct {
   unsigned long a;
   unsigned long b:3;
 } __attribute__((__packed__)) gv1  = { .a = 0x0, .b = 7,  };
 
 // PR5118
-// CHECK: @gv2 ={{.*}} global %struct.anon.0 <{ i8 1, i8* null }>, align 1 
+// CHECK: @gv2 ={{.*}} global %struct.anon.0 <{ i8 1, i8* null }>, align 1
 struct {
   unsigned char a;
   char *b;
 } __attribute__((__packed__)) gv2 = { 1, (void*)0 };
 
 // Global references
 // CHECK: @g11.l0 = internal global i32 ptrtoint (i32 ()* @g11 to i32)
-long g11(void) { 
+long g11(void) {
   static long l0 = (long) g11;
-  return l0; 
+  return l0;
 }
 
 // CHECK: @g12 ={{.*}} global i32 ptrtoint (i8* @g12_tmp to i32)
 static char g12_tmp;
 long g12 = (long) &g12_tmp;
 
 // CHECK: @g13 ={{.*}} global [1 x %struct.g13_s0] [%struct.g13_s0 { i32 ptrtoint (i8* @g12_tmp to i32) }]
 struct g13_s0 {
void g29(void) {
   typedef struct
   {
       DCC_PASSWD passwd;
   } DCC_SRVR_NM;
   // CHECK: @g29.a = internal global %struct.DCC_SRVR_NM { [2 x i8] c"@\00" }, align 1
   // CHECK: @g29.b = internal global [1 x i32] [i32 ptrtoint ([5 x i8]* @.str.1 to i32)], align 4
   // CHECK: @g29.c = internal global [1 x i32] [i32 97], align 4
   static DCC_SRVR_NM a = { {"@"} };
-  static int b[1] = { "asdf" }; // expected-warning {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[5]'}}
+  static int b[1] = { "asdf" };
   static int c[1] = { L"a" };
 }
 
 // PR21300
 void g30(void) {
 #pragma pack(1)
   static struct {
     int : 1;

clang/test/CodeGen/pointer-arithmetic.c

-// RUN: %clang_cc1 -S %s -o -
+// RUN: %clang_cc1 -S -Wno-int-conversions %s -o -
 
 typedef int Int;
 
 int f0(int *a, Int *b) { return a - b; }
 
 int f1(const char *a, char *b) { return b - a; }
 
 // GNU extensions

clang/test/CodeGen/pointer-to-int.c

-// RUN: %clang_cc1 -emit-llvm %s -o -
+// RUN: %clang_cc1 -emit-llvm -Wno-int-conversion %s -o -
 
 int test(void* i)
 {
   return (int)i;
 }
 
 // rdar://6093986
 int test2(void) {
   float x[2];
   return x;
 }
 

clang/test/CodeGen/statements.c

-// RUN: %clang_cc1 -Wno-error=return-type %s -emit-llvm-only
+// RUN: %clang_cc1 -Wno-error=return-type -Wno-error=int-conversion %s -emit-llvm-only
 // REQUIRES: LP64
 
 // Mismatched type between return and function result.
 int test2() { return; }
 void test3() { return 4; }
 
 
 void test4() {

clang/test/CodeGen/struct-init.c

-// RUN: %clang_cc1 -no-opaque-pointers -triple armv7-apple-darwin -target-feature +neon %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers -Wno-int-conversion -triple armv7-apple-darwin -target-feature +neon %s -emit-llvm -o - | FileCheck %s
 
 typedef struct _zend_ini_entry zend_ini_entry;
 struct _zend_ini_entry {
   void *mh_arg1;
 };
 
 char a;
 

clang/test/CodeGen/vla.c

-// RUN: %clang_cc1 -no-opaque-pointers -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK,NULL-INVALID
-// RUN: %clang_cc1 -no-opaque-pointers -triple i386-unknown-unknown %s -emit-llvm -fno-delete-null-pointer-checks -o - | FileCheck %s -check-prefixes=CHECK,NULL-VALID
+// RUN: %clang_cc1 -no-opaque-pointers -Wno-int-conversion -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s -check-prefixes=CHECK,NULL-INVALID
+// RUN: %clang_cc1 -no-opaque-pointers -Wno-int-conversion -triple i386-unknown-unknown %s -emit-llvm -fno-delete-null-pointer-checks -o - | FileCheck %s -check-prefixes=CHECK,NULL-VALID
 
 int b(char* x);
 
 // Extremely basic VLA test
 void a(int x) {
   char arry[x];
   arry[0] = 10;
   b(arry);
void test(void) {
      function(1, bork);
 }
 
 void function1(short width, int data[][width][width]) {}
 void test1(void) {
      int bork[4][13][15];
      // CHECK: call void @function1(i16 noundef signext 1, i32* noundef {{.*}})
      function1(1, bork);
-     // CHECK: call void @function(i16 noundef signext 1, i32* noundef {{.*}}) 
+     // CHECK: call void @function(i16 noundef signext 1, i32* noundef {{.*}})
      function(1, bork[2]);
 }
 
 // rdar://8476159
 static int GLOB;
 int test2(int n)
 {
   GLOB = 0;

clang/test/CodeGenObjC/block-ptr-type-crash.m

-// RUN: %clang_cc1 -Wno-objc-root-class -fblocks -o /dev/null -triple x86_64-- -emit-llvm %s
+// RUN: %clang_cc1 -Wno-objc-root-class -Wno-int-conversion -fblocks -o /dev/null -triple x86_64-- -emit-llvm %s
 // REQUIRES: asserts
 // Verify there is no assertion.
 
 // rdar://30111891
 
 typedef unsigned long long uint64_t;
 typedef enum AnEnum : uint64_t AnEnum;
 enum AnEnum: uint64_t {

clang/test/CodeGenOpenCL/builtins-generic-amdgcn.cl

 // REQUIRES: amdgpu-registered-target
-// RUN: %clang_cc1 -no-opaque-pointers -triple amdgcn-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s
+// RUN: %clang_cc1 -no-opaque-pointers -Wno-error=int-conversion -triple amdgcn-unknown-unknown -S -emit-llvm -o - %s | FileCheck %s
 
 // CHECK-LABEL: @test_builtin_clz(
 // CHECK: tail call i32 @llvm.ctlz.i32(i32 %a, i1 true)
 void test_builtin_clz(global int* out, int a)
 {
   *out = __builtin_clz(a);
 }
 

clang/test/FixIt/dereference-addressof.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // RUN: cp %s %t
 // RUN: not %clang_cc1 -fsyntax-only -fixit -x c %t
 // RUN: %clang_cc1 -fsyntax-only -pedantic -x c %t
 
 void ip(int *aPtr) {}   // expected-note{{passing argument to parameter 'aPtr' here}}
 void i(int a) {}        // expected-note{{passing argument to parameter 'a' here}}
 void ii(int a) {}       // expected-note{{passing argument to parameter 'a' here}}
 void fp(float *aPtr) {} // expected-note{{passing argument to parameter 'aPtr' here}}
 void f(float a) {}      // expected-note{{passing argument to parameter 'a' here}}
 
 void f2(int *aPtr, int a, float *bPtr, char c) {
   float fl = 0;
-  ip(a);     // expected-warning{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'; take the address with &}}
-  i(aPtr);   // expected-warning{{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}
-  ii(&a);     // expected-warning{{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; remove &}}
+  ip(a);     // expected-error{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'; take the address with &}}
+  i(aPtr);   // expected-error{{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}
+  ii(&a);     // expected-error{{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; remove &}}
   fp(*bPtr); // expected-error{{passing 'float' to parameter of incompatible type 'float *'; remove *}}
   f(bPtr);   // expected-error{{passing 'float *' to parameter of incompatible type 'float'; dereference with *}}
-  a = aPtr;  // expected-warning{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
+  a = aPtr;  // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int *'; dereference with *}}
   fl = bPtr + a;  // expected-error{{assigning to 'float' from incompatible type 'float *'; dereference with *}}
   bPtr = bPtr[a]; // expected-error{{assigning to 'float *' from incompatible type 'float'; take the address with &}}
 }

clang/test/FixIt/selector-fixit.m

 // RUN: cp %s %t
-// RUN: %clang_cc1 -x objective-c -Wundeclared-selector -fixit %t
-// RUN: %clang_cc1 -x objective-c -Wundeclared-selector -Werror %t
+// RUN: %clang_cc1 -x objective-c -Wundeclared-selector -Wno-int-conversion -fixit %t
+// RUN: %clang_cc1 -x objective-c -Wundeclared-selector -Wno-int-conversion -Werror %t
 // rdar://14039037
 
 @interface NSObject @end
 
 @interface LogoutController : NSObject
 - (void)close;
 - (void)closed;
 - (void) open : (id) file_id;

clang/test/Misc/serialized-diags.c

 // CHECK: +-{{.*[/\\]}}serialized-diags.c:14:10: note: use '=' to turn this equality comparison into an assignment []
 // CHECK: +-FIXIT: ({{.*[/\\]}}serialized-diags.c:14:10 - {{.*[/\\]}}serialized-diags.c:14:12): "="
 // CHECK: {{.*[/\\]}}serialized-diags.c:22:13: error: too many arguments to function call, expected 2, have 3 []
 // CHECK: Range: {{.*[/\\]}}serialized-diags.c:22:3 {{.*[/\\]}}serialized-diags.c:22:6
 // CHECK: Range: {{.*[/\\]}}serialized-diags.c:22:13 {{.*[/\\]}}serialized-diags.c:22:18
 // CHECK: +-{{.*[/\\]}}serialized-diags.c:20:15: note: expanded from macro 'false' []
 // CHECK: +-Range: {{.*[/\\]}}serialized-diags.c:20:15 {{.*[/\\]}}serialized-diags.c:20:16
 // CHECK: +-{{.*[/\\]}}serialized-diags.c:19:6: note: 'taz' declared here []
-// CHECK: {{.*[/\\]}}serialized-diags.h:5:7: warning: incompatible integer to pointer conversion initializing 'char *' with an expression of type 'int' [-Wint-conversion]
+// CHECK: {{.*[/\\]}}serialized-diags.h:5:7: error: incompatible integer to pointer conversion initializing 'char *' with an expression of type 'int' [-Wint-conversion]
 // CHECK: Range: {{.*[/\\]}}serialized-diags.h:5:16 {{.*[/\\]}}serialized-diags.h:5:17
 // CHECK: +-{{.*[/\\]}}serialized-diags.c:26:10: note: in file included from {{.*[/\\]}}serialized-diags.c:26: []
 // CHECK: Number FIXITs = 0
 // CHECK: {{.*[/\\]}}serialized-diags.c:30:12: warning: unused variable 'x'
 // CHECK: Number FIXITs = 0
 // CHECK: Number of diagnostics: 6

clang/test/Misc/tabstop.c

-// RUN: %clang_cc1 -ftabstop 3 -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-3 -strict-whitespace %s
-// RUN: %clang_cc1 -ftabstop 4 -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-4 -strict-whitespace %s
-// RUN: %clang_cc1 -ftabstop 5 -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-5 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 3 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-3 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 4 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-4 -strict-whitespace %s
+// RUN: %clang_cc1 -ftabstop 5 -fsyntax-only -Wno-error=int-conversion %s 2>&1 | FileCheck -check-prefix=CHECK-5 -strict-whitespace %s
 
 // tab
   void* a = 1;
 
 // tab tab
     void* b = 1;
 
 // 3x space tab

clang/test/Modules/config_macros.m

 @import config;
 
 int *test_foo(void) {
   return foo();
 }
 
 char *test_bar(void) {
   return bar(); // expected-error{{call to undeclared function 'bar'; ISO C99 and later do not support implicit function declarations}} \
-                // expected-warning{{incompatible integer to pointer conversion}}
+                // expected-error{{incompatible integer to pointer conversion}}
 }
 
 #undef WANT_FOO // expected-note{{macro was #undef'd here}}
 @import config; // expected-warning{{#undef of configuration macro 'WANT_FOO' has no effect on the import of 'config'; pass '-UWANT_FOO' on the command line to configure the module}}
 
 #define WANT_FOO 2 // expected-note{{macro was defined here}}
 @import config; // expected-warning{{definition of configuration macro 'WANT_FOO' has no effect on the import of 'config'; pass '-DWANT_FOO=...' on the command line to configure the module}}
 

clang/test/PCH/objc_exprs.m

 // Test this without pch.
 // RUN: %clang_cc1 -fblocks -include %S/objc_exprs.h -fsyntax-only -verify %s
 
 // Test with pch.
 // RUN: %clang_cc1 -x objective-c-header -emit-pch -fblocks -o %t %S/objc_exprs.h
 // RUN: %clang_cc1 -fblocks -include-pch %t -fsyntax-only -verify %s 
 
 // Expressions
 int *A1 = (objc_string)0;   // expected-warning {{aka 'NSString *'}}
 
 char A2 = (objc_encode){};  // expected-error {{not a compile-time constant}} \
-                               expected-warning {{char[2]}}
+                               expected-error {{char[2]}}
 
 int *A3 = (objc_protocol)0; // expected-warning {{aka 'Protocol *'}}
 
 
 // Types.
 int *T0 = (objc_id_protocol_ty)0; // expected-warning {{aka 'id<foo>'}}
 
 int *T1 = (objc_interface_ty)0; // expected-warning {{aka 'itf *'}}
 int *T2 = (objc_qual_interface_ty)0; // expected-warning {{aka 'itf<foo> *'}}
 
 objc_selector_noArgs s1;
 objc_selector_oneArg s2;
 objc_selector_twoArg s3;
 
 

clang/test/Parser/implicit-casts.c

 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
 _Complex double X;
 void test1(int c) {
   X = 5;
 }
 void test2(void) {
   int i;
   double d = i;
   double _Complex a = 5;
 
   test1(a);
   a = 5;
   d = i;
 }
 int test3(void) {
   int a[2];
-  a[0] = test3; // expected-warning{{incompatible pointer to integer conversion assigning to 'int' from 'int (void)'}}
+  a[0] = test3; // expected-error{{incompatible pointer to integer conversion assigning to 'int' from 'int (void)'}}
   return 0;
 }
 short x; void test4(char c) { x += c; }
 int y; void test5(char c) { y += c; }

clang/test/Sema/array-init.c

 // RUN: %clang_cc1 -std=gnu99 -fsyntax-only -pedantic -verify %s
 // RUN: %clang_cc1 -std=gnu99 -fsyntax-only -Wgnu -Wc11-extensions -verify %s
 // REQUIRES: LP64
 
 extern int foof(void) = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
 
 static int x, y, z;
 
 static int ary[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
 int ary2[] = { x, y, z }; // expected-error{{initializer element is not a compile-time constant}}
 
 extern int fileScopeExtern[3] = { 1, 3, 5 }; // expected-warning{{'extern' variable has an initializer}}
 
-static long ary3[] = { 1, "abc", 3, 4 }; // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[4]'}}
+static long ary3[] = { 1, "abc", 3, 4 }; // expected-error{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[4]'}}
 
 void func(void) {
   int x = 1;
 
   typedef int TInt = 1; // expected-error{{illegal initializer (only variables can be initialized)}}
 
   int xComputeSize[] = { 1, 3, 5 };
 
   int x3[x] = { 1, 2 }; // expected-error{{variable-sized object may not be initialized}}
 
   int x4 = { 1, 2 }; // expected-warning{{excess elements in scalar initializer}}
 
-  int y[4][3] = { 
+  int y[4][3] = {
     { 1, 3, 5 },
     { 2, 4, 6 },
     { 3, 5, 7 },
   };
 
   int y2[4][3] = {
     1, 3, 5, 2, 4, 6, 3, 5, 7
   };
 
-  int y3[4][3] = {  
+  int y3[4][3] = {
     { 1, 3, 5 },
     { 2, 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
     { 5 }, // expected-warning{{excess elements in array initializer}}
   };
 
   struct threeElements {
     int a,b,c;
   } z = { 1 };
 
-  struct threeElements *p = 7; // expected-warning{{incompatible integer to pointer conversion initializing 'struct threeElements *' with an expression of type 'int'}}
-  
+  struct threeElements *p = 7; // expected-error{{incompatible integer to pointer conversion initializing 'struct threeElements *' with an expression of type 'int'}}
   extern int blockScopeExtern[3] = { 1, 3, 5 }; // expected-error{{'extern' variable cannot have an initializer}}
-  
   static long x2[3] = { 1.0,
-                        "abc", // expected-warning{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[4]'}}
+                        "abc", // expected-error{{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[4]'}}
                          5.8 }; // expected-warning {{implicit conversion from 'double' to 'long' changes value from 5.8 to 5}}
 }
 
 void test(void) {
-  int y1[3] = { 
+  int y1[3] = {
     { 1, 2, 3 } // expected-warning{{excess elements in scalar initializer}}
   };
-  int y3[4][3] = {  
+  int y3[4][3] = {
     { 1, 3, 5 },
     { 2, 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
     {  }, // expected-warning{{use of GNU empty initializer extension}} expected-warning{{excess elements in array initializer}}
   };
-  int y4[4][3] = {  
+  int y4[4][3] = {
     { 1, 3, 5, 2 }, // expected-warning{{excess elements in array initializer}}
     { 4, 6 },
     { 3, 5, 7 },
     { 4, 6, 8 },
   };
 }
 
 void allLegalAndSynonymous(void) {
   short q[4][3][2] = {
     { 1 },
     { 2, 3 },
     { 4, 5, 6 }
   };
   short q2[4][3][2] = {
     { 1, 0, 0, 0, 0, 0 },
     { 2, 3, 0, 0, 0, 0 },
     { 4, 5, 6 }
   };
   short q3[4][3][2] = {
-    { 
+    {
       { 1 },
     },
-    { 
+    {
       { 2, 3 },
     },
-    { 
+    {
       { 4, 5 },
       { 6 },
     },
   };
 }
 
 void legal(void) {
   short q[][3][2] = {
     { 1 },
     { 2, 3 },
     { 4, 5, 6 }
   };
   int q_sizecheck[(sizeof(q) / sizeof(short [3][2])) == 3? 1 : -1];
 }
 
 unsigned char asso_values[] = { 34 };
-int legal2(void) { 
-  return asso_values[0]; 
+int legal2(void) {
+  return asso_values[0];
 }
 
 void illegal(void) {
   short q2[4][][2] = { // expected-error{{array has incomplete element type 'short[][2]'}}
     { 1, 0, 0, 0, 0, 0 },
     { 2, 3, 0, 0, 0, 0 },
     { 4, 5, 6 }
   };
   short q3[4][3][] = { // expected-error{{array has incomplete element type 'short[]'}}
-    { 
+    {
       { 1 },
     },
-    { 
+    {
       { 2, 3 },
     },
-    { 
+    {
       { 4, 5 },
       { 6 },
     },
   };
   int a[][] = { 1, 2 }; // expected-error{{array has incomplete element type 'int[]'}}
 }
 
 typedef int AryT[];

 #pragma clang diagnostic ignored "-Wexcess-initializers"
   static char const test3_quiet[] = {"test", "excess stuff"};
 #pragma clang diagnostic pop
 
   char* cp[] = { "Hello" };
 
   char c[] = { "Hello" };
   int l[sizeof(c) == 6 ? 1 : -1];
-  
-  int i[] = { "Hello "}; // expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[7]'}}
+  int i[] = { "Hello "}; // expected-error{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[7]'}}
   char c2[] = { "Hello", "Good bye" }; //expected-warning{{excess elements in char array initializer}}
 
-  int i2[1] = { "Hello" }; //expected-warning{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[6]'}}
+  int i2[1] = { "Hello" }; //expected-error{{incompatible pointer to integer conversion initializing 'int' with an expression of type 'char[6]'}}
   char c3[5] = { "Hello" };
   char c4[4] = { "Hello" }; //expected-warning{{initializer-string for char array is too long}}
 
   int i3[] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
 }
 
 void variableArrayInit(void) {
   int a = 4;

 unsigned char r10[] = __extension__ (_Generic(0, int: (__extension__ "foo" )));
 int r11[0] = {}; //expected-warning{{zero size arrays are an extension}} expected-warning{{use of GNU empty initializer extension}}
 
 // Some struct tests
 void autoStructTest(void) {
 struct s1 {char a; char b;} t1;
 struct s2 {struct s1 c;} t2 = { t1 };
 // The following is a less than great diagnostic (though it's on par with EDG).
-struct s1 t3[] = {t1, t1, "abc", 0}; //expected-warning{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char[4]'}}
+struct s1 t3[] = {t1, t1, "abc", 0}; //expected-error{{incompatible pointer to integer conversion initializing 'char' with an expression of type 'char[4]'}}
 int t4[sizeof t3 == 6 ? 1 : -1];
 }
 struct foo { int z; } w;
-int bar (void) { 
+int bar (void) {
   struct foo z = { w }; //expected-error{{initializing 'int' with an expression of incompatible type 'struct foo'}}
-  return z.z; 
-} 
+  return z.z;
+}
 struct s3 {void (*a)(void);} t5 = {autoStructTest};
 struct {int a; int b[];} t6 = {1, {1, 2, 3}}; // expected-warning{{flexible array initialization is a GNU extension}} \
 // expected-note{{initialized flexible array member 'b' is here}}
 union {char a; int b;} t7[] = {1, 2, 3};
 int t8[sizeof t7 == (3*sizeof(int)) ? 1 : -1];
 
 struct bittest{int : 31, a, :21, :12, b;};
 struct bittest bittestvar = {1, 2, 3, 4}; //expected-warning{{excess elements in struct initializer}}
const Matrix mat1 = {
         9.0f, 10.0f, 11.0f, 12.0f,
         13.0f, 14.0f, 15.0f, 16.0f } }
   };
 
   const Matrix mat2 = {
     1.0f, 2.0f, 3.0f, 4.0f,
     5.0f, 6.0f, 7.0f, 8.0f,
     9.0f, 10.0f, 11.0f, 12.0f,
-    13.0f, 14.0f, 15.0f, 16.0f 
+    13.0f, 14.0f, 15.0f, 16.0f
   };
 }
 
 char badchararray[1] = { badchararray[0], "asdf" }; // expected-warning {{excess elements in array initializer}} expected-error {{initializer element is not a compile-time constant}}
 
 // Test the GNU extension for initializing an array from an array
 // compound literal. PR9261.
 typedef int int5[5];

clang/test/Sema/atomic-ops.c

void f(_Atomic(int) *i, const _Atomic(int) *ci,
   __atomic_load(I, *P, memory_order_relaxed, 42); // expected-error {{too many arguments}}
   (int)__atomic_load(I, I, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
   __atomic_load(s1, s2, memory_order_acquire);
   __atomic_load(CI, I, memory_order_relaxed);
   __atomic_load(I, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
   __atomic_load(CI, CI, memory_order_relaxed); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
 
   __c11_atomic_store(i, 1, memory_order_seq_cst);
-  __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-warning {{incompatible integer to pointer conversion}}
+  __c11_atomic_store(p, 1, memory_order_seq_cst); // expected-error {{incompatible integer to pointer conversion}}
   (int)__c11_atomic_store(f, 1, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
 
   __atomic_store_n(I, 4, memory_order_release);
   __atomic_store_n(I, 4.0, memory_order_release);
   __atomic_store_n(CI, 4, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}
-  __atomic_store_n(I, P, memory_order_release); // expected-warning {{parameter of type 'int'}}
+  __atomic_store_n(I, P, memory_order_release); // expected-error {{parameter of type 'int'}}
   __atomic_store_n(i, 1, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
   __atomic_store_n(s1, *s2, memory_order_release); // expected-error {{must be a pointer to integer or pointer}}
-  __atomic_store_n(I, I, memory_order_release); // expected-warning {{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}
+  __atomic_store_n(I, I, memory_order_release); // expected-error {{incompatible pointer to integer conversion passing 'int *' to parameter of type 'int'; dereference with *}}
 
   __atomic_store(I, *P, memory_order_release);
   __atomic_store(CI, I, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}
   __atomic_store(s1, s2, memory_order_release);
   __atomic_store(i, I, memory_order_release); // expected-error {{trivially-copyable}}
 
   int exchange_1 = __c11_atomic_exchange(i, 1, memory_order_seq_cst);
   int exchange_2 = __c11_atomic_exchange(I, 1, memory_order_seq_cst); // expected-error {{must be a pointer to _Atomic}}
void f(_Atomic(int) *i, const _Atomic(int) *ci,
 
   _Bool cmpexchw_1 = __c11_atomic_compare_exchange_weak(i, I, 1, memory_order_seq_cst, memory_order_seq_cst);
   _Bool cmpexchw_2 = __c11_atomic_compare_exchange_weak(p, P, (int*)1, memory_order_seq_cst, memory_order_seq_cst);
   _Bool cmpexchw_3 = __c11_atomic_compare_exchange_weak(f, I, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{incompatible pointer types}}
   (void)__c11_atomic_compare_exchange_weak(i, CI, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
 
   _Bool cmpexch_4 = __atomic_compare_exchange_n(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst);
   _Bool cmpexch_5 = __atomic_compare_exchange_n(I, P, 5, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
-  _Bool cmpexch_6 = __atomic_compare_exchange_n(I, I, P, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int **' to parameter of type 'int'}}
+  _Bool cmpexch_6 = __atomic_compare_exchange_n(I, I, P, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{passing 'int **' to parameter of type 'int'}}
   (void)__atomic_compare_exchange_n(CI, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}
   (void)__atomic_compare_exchange_n(I, CI, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
 
-  _Bool cmpexch_7 = __atomic_compare_exchange(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'int' to parameter of type 'int *'}}
+  _Bool cmpexch_7 = __atomic_compare_exchange(I, I, 5, 1, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{passing 'int' to parameter of type 'int *'}}
   _Bool cmpexch_8 = __atomic_compare_exchange(I, P, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{; dereference with *}}
   _Bool cmpexch_9 = __atomic_compare_exchange(I, I, I, 0, memory_order_seq_cst, memory_order_seq_cst);
   (void)__atomic_compare_exchange(CI, I, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-error {{address argument to atomic operation must be a pointer to non-const type ('const int *' invalid)}}
   (void)__atomic_compare_exchange(I, CI, I, 0, memory_order_seq_cst, memory_order_seq_cst); // expected-warning {{passing 'const int *' to parameter of type 'int *' discards qualifiers}}
 
   // Pointers to different address spaces are allowed.
   _Bool cmpexch_10 = __c11_atomic_compare_exchange_strong((_Atomic int _AS1 *)0x308, (int _AS2 *)0x309, 1, memory_order_seq_cst, memory_order_seq_cst);
 
   const volatile int flag_k = 0;
   volatile int flag = 0;
   (void)(int)__atomic_test_and_set(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
   (void)(int)__atomic_test_and_set(&flag, memory_order_seq_cst);
   __atomic_clear(&flag_k, memory_order_seq_cst); // expected-warning {{passing 'const volatile int *' to parameter of type 'volatile void *'}}
   __atomic_clear(&flag, memory_order_seq_cst);
   (int)__atomic_clear(&flag, memory_order_seq_cst); // expected-error {{operand of type 'void'}}
 
   __c11_atomic_init(ci, 0); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}
   __c11_atomic_store(ci, 0, memory_order_release); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const _Atomic(int) *' invalid)}}
   __c11_atomic_load(ci, memory_order_acquire);
 
   // Ensure the <stdatomic.h> macros behave appropriately.
   atomic_int n = ATOMIC_VAR_INIT(123);
   atomic_init(&n, 456);
-  atomic_init(&n, (void*)0); // expected-warning {{passing 'void *' to parameter of type 'int'}}
+  atomic_init(&n, (void*)0); // expected-error {{passing 'void *' to parameter of type 'int'}}
 
   const atomic_wchar_t cawt;
   atomic_init(&cawt, L'x'); // expected-error {{non-const}}
   atomic_wchar_t awt;
   atomic_init(&awt, L'x');
 
   int x = kill_dependency(12);
 
   atomic_thread_fence(); // expected-error {{too few arguments to function call}}
   atomic_thread_fence(memory_order_seq_cst);
   atomic_signal_fence(memory_order_seq_cst);
   void (*pfn)(memory_order) = &atomic_thread_fence;
   pfn = &atomic_signal_fence;
 
   int k = atomic_load_explicit(&n, memory_order_relaxed);
   atomic_store_explicit(&n, k, memory_order_relaxed);
   atomic_store(&n, atomic_load(&n));
 
   k = atomic_exchange(&n, 72);
   k = atomic_exchange_explicit(&n, k, memory_order_release);
 
-  atomic_compare_exchange_strong(&n, k, k); // expected-warning {{take the address with &}}
+  atomic_compare_exchange_strong(&n, k, k); // expected-error {{take the address with &}}
   atomic_compare_exchange_weak(&n, &k, k);
   atomic_compare_exchange_strong_explicit(&n, &k, k, memory_order_seq_cst); // expected-error {{too few arguments}}
   atomic_compare_exchange_weak_explicit(&n, &k, k, memory_order_seq_cst, memory_order_acquire);
 
   atomic_fetch_add(&k, n); // expected-error {{must be a pointer to _Atomic}}
   k = atomic_fetch_add(&n, k);
   k = atomic_fetch_sub(&n, k);
   k = atomic_fetch_and(&n, k);

clang/test/Sema/block-return.c

bptr foo5(int j) {
   if (j)
     return ^{ ^{ i=0; }(); };  // expected-error {{returning block that lives on the local stack}}
   return ^{ i=0; };  // expected-error {{returning block that lives on the local stack}}
   return (^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
   return (void*)(^{ i=0; });  // expected-error {{returning block that lives on the local stack}}
 }
 
 int (*funcptr3[5])(long);
-int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block cannot return array type}} expected-warning {{incompatible pointer to integer conversion}}
+int sz8 = sizeof(^int (*[5])(long) {return funcptr3;}); // expected-error {{block cannot return array type}} expected-error {{incompatible pointer to integer conversion}}
 int sz9 = sizeof(^int(*())()[3]{ }); // expected-error {{function cannot return array type}}
                                      // expected-warning@-1 {{a function declaration without a prototype is deprecated in all versions of C}}
 
 void foo6(void) {
   int (^b)(int) __attribute__((noreturn));
   b = ^ (int i) __attribute__((noreturn)) { return 1; };  // expected-error {{block declared 'noreturn' should not return}}
   b(1);
   int (^c)(void) __attribute__((noreturn)) = ^ __attribute__((noreturn)) { return 100; }; // expected-error {{block declared 'noreturn' should not return}}

clang/test/Sema/builtin-alloca-with-align.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 void test1(int a) {
   __builtin_alloca_with_align(a, 32);
 }
 
 void test2(int a) {
   __builtin_alloca_with_align(a, -32); // expected-error {{requested alignment is not a power of 2}}
 }
 
 void test3(unsigned *b) {
-  __builtin_alloca_with_align(b, 32); // expected-warning {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of type}}
+  __builtin_alloca_with_align(b, 32); // expected-error {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of type}}
 }
 
 void test4(int a) {
   __builtin_alloca_with_align(a, 32, 0); // expected-error {{too many arguments to function call, expected 2, have 3}}
 }
 
 void test5(int a) {
   __builtin_alloca_with_align(a, 31); // expected-error {{requested alignment is not a power of 2}}

clang/test/Sema/builtin-assume-aligned.c

 }
 
 int test4(int *a) {
   a = __builtin_assume_aligned(a, -32); // expected-error {{requested alignment is not a power of 2}}
   return a[0];
 }
 
 int test5(int *a, unsigned *b) {
-  a = __builtin_assume_aligned(a, 32, b); // expected-warning {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of type}}
+  a = __builtin_assume_aligned(a, 32, b); // expected-error {{incompatible pointer to integer conversion passing 'unsigned int *' to parameter of type}}
   return a[0];
 }
 
 int test6(int *a) {
   a = __builtin_assume_aligned(a, 32, 0, 0); // expected-error {{too many arguments to function call, expected at most 3, have 4}}
   return a[0];
 }
 

clang/test/Sema/builtin-dump-struct.c

void invalid_uses(void) {
   int (*badfunc3)(void);
 
   __builtin_dump_struct();             // expected-error {{too few arguments to function call, expected 2, have 0}}
   __builtin_dump_struct(1);            // expected-error {{too few arguments to function call, expected 2, have 1}}
   __builtin_dump_struct(1, 2);         // expected-error {{expected pointer to struct as 1st argument to '__builtin_dump_struct', found 'int'}}
   __builtin_dump_struct(&a, 2);        // expected-error {{expected a callable expression as 2nd argument to '__builtin_dump_struct', found 'int'}}
   __builtin_dump_struct(b, goodfunc); // expected-error {{expected pointer to struct as 1st argument to '__builtin_dump_struct', found 'void *'}}
   __builtin_dump_struct(&a, badfunc1); // expected-error {{too many arguments to function call, expected 1, have 2}} expected-note  {{in call to printing function with arguments '("%s", "struct A")'}}
-  __builtin_dump_struct(&a, badfunc2); // expected-warning-re 1+{{incompatible pointer to integer conversion passing 'char[{{.*}}]' to parameter of type 'int'}}
+  __builtin_dump_struct(&a, badfunc2); // expected-error-re 1+{{incompatible pointer to integer conversion passing 'char[{{.*}}]' to parameter of type 'int'}}
                                        // expected-note@-1 1+{{in call to printing function with arguments '("}}
   __builtin_dump_struct(&a, badfunc3); // expected-error {{too many arguments to function call, expected 0, have 2}} expected-note {{in call to printing function with arguments '("%s", "struct A")'}}
   __builtin_dump_struct(a, goodfunc);  // expected-error {{expected pointer to struct as 1st argument to '__builtin_dump_struct', found 'struct A'}}
 }
 
 int goodglobalfunc(const char*, ...);
 
 void valid_uses(void) {

clang/test/Sema/builtins-bpf.c

unsigned invalid1(const int *arg) {
   return __builtin_preserve_field_info(arg, 1); // expected-error {{__builtin_preserve_field_info argument 1 not a field access}}
 }
 
 unsigned invalid2(const int *arg) {
   return __builtin_preserve_field_info(*arg, 1); // expected-error {{__builtin_preserve_field_info argument 1 not a field access}}
 }
 
 void *invalid3(struct s *arg) {
-  return __builtin_preserve_field_info(arg->a, 1); // expected-warning {{incompatible integer to pointer conversion returning 'unsigned int' from a function with result type 'void *'}}
+  return __builtin_preserve_field_info(arg->a, 1); // expected-error {{incompatible integer to pointer conversion returning 'unsigned int' from a function with result type 'void *'}}
 }
 
 unsigned valid4(struct s *arg) {
   return __builtin_preserve_field_info(arg->b[1], 1);
 }
 
 unsigned valid5(union u *arg) {
   return __builtin_preserve_field_info(arg->b[2], 1);

clang/test/Sema/builtins.c

 }
 
 
 #define CFSTR __builtin___CFStringMakeConstantString
 void test7(void) {
   const void *X;
   X = CFSTR("\242"); // expected-warning {{input conversion stopped}}
   X = CFSTR("\0"); // no-warning
-  X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-warning {{incompatible integer to pointer conversion}}
+  X = CFSTR(242); // expected-error {{CFString literal is not a string constant}} expected-error {{incompatible integer to pointer conversion}}
   X = CFSTR("foo", "bar"); // expected-error {{too many arguments to function call}}
 }
 
 
 // atomics.
 
 void test9(short v) {
   unsigned i, old;
void test18(void) {
   size_t result;
   void *ptr;
 
   ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src), sizeof(dst));
   result = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst));
   result = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst));
 
   ptr = __builtin___memccpy_chk(dst, src, '\037', sizeof(src));      // expected-error {{too few arguments to function call}}
-  ptr = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
-  ptr = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-warning {{incompatible integer to pointer conversion}}
+  ptr = __builtin___strlcpy_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-error {{incompatible integer to pointer conversion}}
+  ptr = __builtin___strlcat_chk(dst, src, sizeof(dst), sizeof(dst)); // expected-error {{incompatible integer to pointer conversion}}
 }
 
 void no_ms_builtins(void) {
   __assume(1); // expected-error {{call to undeclared function '__assume'; ISO C99 and later do not support implicit function declarations}}
   __noop(1); // expected-error {{call to undeclared function '__noop'; ISO C99 and later do not support implicit function declarations}}
   __debugbreak(); // expected-error {{call to undeclared function '__debugbreak'; ISO C99 and later do not support implicit function declarations}}
 }
 

clang/test/Sema/compound-literal.c

 // RUN: %clang_cc1 -fsyntax-only -verify -fblocks -pedantic %s
 // REQUIRES: LP64
 
 struct foo { int a, b; };
 
 static struct foo t = (struct foo){0,0};
 static struct foo t1 = __builtin_choose_expr(0, (struct foo){0,0}, (struct foo){0,0});
 static struct foo t2 = {0,0};
 static struct foo t3 = t2; // expected-error {{initializer element is not a compile-time constant}}
 static int *p = (int []){2,4};
 static int x = (int){1};
 
 static int *p2 = (int []){2,x}; // expected-error {{initializer element is not a compile-time constant}}
-static long *p3 = (long []){2,"x"}; // expected-warning {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[2]'}}
+static long *p3 = (long []){2,"x"}; // expected-error {{incompatible pointer to integer conversion initializing 'long' with an expression of type 'char[2]'}}
 
 typedef struct { } cache_t; // expected-warning{{empty struct is a GNU extension}}
 static cache_t clo_I1_cache = ((cache_t) { } ); // expected-warning{{use of GNU empty initializer extension}}
 
 typedef struct Test {int a;int b;} Test;
 static Test* ll = &(Test) {0,0};
 
 extern void fooFunc(struct foo *pfoo);

clang/test/Sema/conditional-expr.c

 }
 
 #define nil ((void*) 0)
 
 extern int f1(void);
 
 int f0(int a) {
   // GCC considers this a warning.
-  return a ? f1() : nil; // expected-warning {{pointer/integer type mismatch in conditional expression ('int' and 'void *')}} expected-warning {{incompatible pointer to integer conversion returning 'void *' from a function with result type 'int'}}
+  return a ? f1() : nil; // expected-warning {{pointer/integer type mismatch in conditional expression ('int' and 'void *')}} expected-error {{incompatible pointer to integer conversion returning 'void *' from a function with result type 'int'}}
 }
 
 int f2(int x) {
   // We can suppress this because the immediate context wants an int.
   return (x != 0) ? 0U : x;
 }
 
 #define NULL (void*)0

clang/test/Sema/enum.c

 // RUN: %clang_cc1 -triple %itanium_abi_triple %s -fsyntax-only -verify -pedantic
-enum e {A, 
+enum e {A,
         B = 42LL << 32,        // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
       C = -4, D = 12456 };
 
 enum f { a = -2147483648, b = 2147483647 }; // ok.
 
 enum g {  // too negative
    c = -2147483649,         // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
    d = 2147483647 };
 enum h { e = -2147483648, // too pos
    f = 2147483648,           // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
   i = 0xFFFF0000 // expected-warning {{too large}}
-}; 
+};
 
 // minll maxull
 enum x                      // expected-warning {{enumeration values exceed range of largest integer}}
 { y = -9223372036854775807LL-1,  // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
 z = 9223372036854775808ULL };    // expected-warning {{ISO C restricts enumerator values to range of 'int'}}
 
 int test(void) {
   return sizeof(enum e) ;
static enum e1 badfunc(struct s1 *q) {
   return q->bar();
 }
 
 
 // Make sure we don't a.k.a. anonymous enums.
 typedef enum {
   an_enumerator = 20
 } an_enum;
-char * s = (an_enum) an_enumerator; // expected-warning {{incompatible integer to pointer conversion initializing 'char *' with an expression of type 'an_enum'}}
+char * s = (an_enum) an_enumerator; // expected-error {{incompatible integer to pointer conversion initializing 'char *' with an expression of type 'an_enum'}}
 
 // PR4515
 enum PR4515 {PR4515a=1u,PR4515b=(PR4515a-2)/2};
 int CheckPR4515[PR4515b==0?1:-1];
 
 // PR7911
 extern enum PR7911T PR7911V; // expected-warning{{ISO C forbids forward references to 'enum' types}}
 void PR7911F(void) {

clang/test/Sema/extern-redecl.c

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-strict-prototypes %s
 
 // rdar: // 8125274
 static int a16[];  // expected-warning {{tentative array definition assumed to have one element}}
 
 void f16(void) {
     extern int a16[];
 }
 
 
 // PR10013: Scope of extern declarations extend past enclosing block
 extern int PR10013_x;
 int PR10013(void) {
   int *PR10013_x = 0;
   {
     extern int PR10013_x;
-    extern int PR10013_x; 
+    extern int PR10013_x;
   }
-  
-  return PR10013_x; // expected-warning{{incompatible pointer to integer conversion}}
+  return PR10013_x; // expected-error{{incompatible pointer to integer conversion}}
 }
 
 static int test1_a[]; // expected-warning {{tentative array definition assumed to have one element}}
 extern int test1_a[];
 
 // rdar://13535367
 void test2declarer(void) { extern int test2_array[100]; }
 extern int test2_array[];

clang/test/Sema/format-strings.c

void check_string_literal( FILE* fp, const char* s, char *buf, ... ) {
   printf(fmt, 1, 2); // expected-warning{{data argument not used}}
 
   // rdar://6079877
   printf("abc"
          "%*d", 1, 1); // no-warning
   printf("abc\
 def"
          "%*d", 1, 1); // no-warning
-         
   // <rdar://problem/6079850>, allow 'unsigned' (instead of 'int') to be used for both
   // the field width and precision.  This deviates from C99, but is reasonably safe
   // and is also accepted by GCC.
-  printf("%*d", (unsigned) 1, 1); // no-warning  
+  printf("%*d", (unsigned) 1, 1); // no-warning
 }
 
 // When calling a non-variadic format function (vprintf, vscanf, NSLogv, ...),
 // warn only if the format string argument is a parameter that is not itself
 // declared as a format string with compatible format.
 __attribute__((__format__ (__printf__, 2, 4)))
 void check_string_literal2( FILE* fp, const char* s, char *buf, ... ) {
   char * b;

 }
 
 void check_empty_format_string(char* buf, ...)
 {
   va_list ap;
   va_start(ap,buf);
   vprintf("",ap); // expected-warning {{format string is empty}}
   sprintf(buf, "", 1); // expected-warning {{format string is empty}}
-  
   // Don't warn about empty format strings when there are no data arguments.
   // This can arise from macro expansions and non-standard format string
   // functions.
   sprintf(buf, ""); // no-warning
 }
 
 void check_wide_string(char* b, ...)
 {

 }
 
 void test_constant_bindings(void) {
   const char * const s1 = "hello";
   const char s2[] = "hello";
   const char *s3 = "hello";
   char * const s4 = "hello";
   extern const char s5[];
-  
   printf(s1); // no-warning
   printf(s2); // no-warning
   printf(s3); // expected-warning{{not a string literal}}
   // expected-note@-1{{treat the string as an argument to avoid this}}
   printf(s4); // expected-warning{{not a string literal}}
   // expected-note@-1{{treat the string as an argument to avoid this}}
   printf(s5); // expected-warning{{not a string literal}}
   // expected-note@-1{{treat the string as an argument to avoid this}}
 }
 
 
 // Test what happens when -Wformat-security only.
 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
 #pragma GCC diagnostic warning "-Wformat-security"
 
 void test9(char *P) {
   int x;
   printf(P);   // expected-warning {{format string is not a string literal (potentially insecure)}}
   // expected-note@-1{{treat the string as an argument to avoid this}}
   printf(P, 42);
 }
 
 void torture(va_list v8) {
   vprintf ("%*.*d", v8);  // no-warning
-  
 }
 
 void test10(int x, float f, int i, long long lli) {
   printf("%s"); // expected-warning{{more '%' conversions than data arguments}}
   printf("%@", 12); // expected-warning{{invalid conversion specifier '@'}}
   printf("\0"); // expected-warning{{format string contains '\0' within the string body}}
   printf("xs\0"); // expected-warning{{format string contains '\0' within the string body}}
   printf("%*d\n"); // expected-warning{{'*' specified field width is missing a matching 'int' argument}}
void test11(void *p, char *s) {
   printf("%0s", p); // expected-warning{{flag '0' results in undefined behavior with 's' conversion specifier}}
                     // expected-warning@-1 {{format specifies type 'char *' but the argument has type 'void *'}}
 }
 
 void test12(char *b) {
   unsigned char buf[4];
   printf ("%.4s\n", buf); // no-warning
   printf ("%.4s\n", &buf); // expected-warning{{format specifies type 'char *' but the argument has type 'unsigned char (*)[4]'}}
-  
   // Verify that we are checking asprintf
   asprintf(&b, "%d", "asprintf"); // expected-warning{{format specifies type 'int' but the argument has type 'char *'}}
 }
 
 void test13(short x) {
   char bel = 007;
   printf("bel: '0%hhd'\n", bel); // no-warning
   printf("x: '0%hhd'\n", x); // expected-warning {{format specifies type 'char' but the argument has type 'short'}}
void rdar8269537(void) {
   // doesn't warn in this case.
   printf(0); // no-warning
 }
 
 // Handle functions with multiple format attributes.
 extern void rdar8332221_vprintf_scanf(const char *, va_list, const char *, ...)
      __attribute__((__format__(__printf__, 1, 0)))
      __attribute__((__format__(__scanf__, 3, 4)));
-     
 void rdar8332221(va_list ap, int *x, long *y) {
   rdar8332221_vprintf_scanf("%", ap, "%d", x); // expected-warning{{incomplete format specifier}}
 }
 
 // PR8641
 void pr8641(void) {
   printf("%#x\n", 10);
   printf("%#X\n", 10);
void test_char_pointer_arithmetic(int b) {
 
   const char s7[] = "%s string %s %s";
   printf(s7 + 3, "");  // expected-warning{{more '%' conversions than data arguments}}
   // expected-note@-2{{format string is defined here}}
 }
 
 void PR30481(void) {
   // This caused crashes due to invalid casts.
-  printf(1 > 0); // expected-warning{{format string is not a string literal}} expected-warning{{incompatible integer to pointer conversion}} expected-note@format-strings.c:*{{passing argument to parameter here}} expected-note{{to avoid this}}
+  printf(1 > 0); // expected-warning{{format string is not a string literal}} expected-error{{incompatible integer to pointer conversion}} expected-note@format-strings.c:*{{passing argument to parameter here}} expected-note{{to avoid this}}
 }
 
 void test_printf_opaque_ptr(void *op) {
   printf("%s", op); // expected-warning{{format specifies type 'char *' but the argument has type 'void *'}}
 }
 
 void test_block(void) {
   void __attribute__((__format__(__printf__, 1, 2))) (^printf_arg1)(

clang/test/Sema/function-redecl.c

 void outer_test3(void) {
   int *(*fp)(int) = outer8; // expected-error{{use of undeclared identifier 'outer8'}}
 }
 
 enum e { e1, e2 };
 
 // GNU extension: prototypes and K&R function definitions
 int isroot(short x, // expected-note{{previous declaration is here}}
-           enum e); 
+           enum e);
 
 int isroot(x, y)
      short x; // expected-warning{{promoted type 'int' of K&R function parameter is not compatible with the parameter type 'short' declared in a previous prototype}}
      unsigned int y;
 {
   return x == 1;
 }
 
 // PR3817
 void *h0(unsigned a0,     ...);
 extern __typeof (h0) h1 __attribute__((__sentinel__));
 extern __typeof (h1) h1 __attribute__((__sentinel__));
 
 // PR3840
 void i0 (unsigned short a0);
 extern __typeof (i0) i1;
 extern __typeof (i1) i1;
 
 typedef int a();
 typedef int a2(int*);
 a x;
 a2 x2; // expected-note{{passing argument to parameter here}}
 void test_x(void) {
   x(5);
-  x2(5); // expected-warning{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'}}
+  x2(5); // expected-error{{incompatible integer to pointer conversion passing 'int' to parameter of type 'int *'}}
 }
 
-enum e0 {one}; 
-void f3(); 
+enum e0 {one};
+void f3();
 void f3(enum e0 x) {}
 
 enum incomplete_enum;
 void f4(); // expected-note {{previous declaration is here}}
 void f4(enum incomplete_enum); // expected-error {{conflicting types for 'f4'}}

clang/test/Sema/function.c

 // RUN: %clang_cc1 %s -fsyntax-only -verify -verify=c2x -pedantic -Wno-strict-prototypes
 
 // PR1892, PR11354
-void f(double a[restrict][5]) { __typeof(a) x = 10; } // expected-warning {{(aka 'double (*restrict)[5]')}}
+void f(double a[restrict][5]) { __typeof(a) x = 10; } // expected-error {{(aka 'double (*restrict)[5]')}}
 
 int foo (__const char *__path);
 int foo(__const char *__restrict __file);
 
 void func(const char*); // expected-note {{previous declaration is here}}
 void func(char*); // expected-error{{conflicting types for 'func'}}
 
 void g(int (*)(const void **, const void **));

clang/test/Sema/i-c-e.c

 int illegaldiv3[INT_MIN / -1]; // expected-error {{variable length array declaration not allowed at file scope}}
 // PR9262
 int illegaldiv4[0 / (1 / 0)]; // expected-error {{variable length array declaration not allowed at file scope}}
 
 int chooseexpr[__builtin_choose_expr(1, 1, expr)];
 int realop[(__real__ 4) == 4 ? 1 : -1];
 int imagop[(__imag__ 4) == 0 ? 1 : -1];
 
-int *PR14729 = 0 ?: 1/0; // expected-error {{not a compile-time constant}} expected-warning 3{{}}
+int *PR14729 = 0 ?: 1/0; // expected-error {{not a compile-time constant}} expected-warning 2{{}} expected-error {{incompatible integer to pointer conversion initializing 'int *' with an expression of type 'int'}}
 
 int bcp_call_v;
 int bcp_call_a[] = {__builtin_constant_p(bcp_call_v && 0) ? bcp_call_v && 0 : -1};

clang/test/Sema/indirect-goto.c

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct c {int x;};
 int a(struct c x, long long y) {
   void const* l1_ptr = &&l1;
   goto *l1_ptr;
 l1:
   goto *x; // expected-error{{incompatible type}}
-  goto *y; // expected-warning{{incompatible integer to pointer conversion}}
+  goto *y; // expected-error{{incompatible integer to pointer conversion}}
 }
 

clang/test/Sema/matrix-type-builtins.c

void column_major_load(float *p1, int *p2, _Bool *p3, struct Foo *p4) {
   // expected-error@-1 {{row dimension is outside the allowed range [1, 1048575}}
   sx5x10_t a11 = __builtin_matrix_column_major_load(p1, 10, 1ull << 21, 10);
   // expected-error@-1 {{column dimension is outside the allowed range [1, 1048575}}
 
   sx5x10_t a12 = __builtin_matrix_column_major_load(
       10,         // expected-error {{1st argument must be a pointer to a valid matrix element type}}
       1ull << 21, // expected-error {{row dimension is outside the allowed range [1, 1048575]}}
       1ull << 21, // expected-error {{column dimension is outside the allowed range [1, 1048575]}}
-      "");        // expected-warning {{incompatible pointer to integer conversion casting 'char[1]' to type 'unsigned long'}}
+      "");        // expected-error {{incompatible pointer to integer conversion casting 'char[1]' to type 'unsigned long'}}
 
   sx5x10_t a13 = __builtin_matrix_column_major_load(
       10,  // expected-error {{1st argument must be a pointer to a valid matrix element type}}
       *p4, // expected-error {{casting 'struct Foo' to incompatible type 'unsigned long'}}
       "",  // expected-error {{column argument must be a constant unsigned integer expression}}
-           // expected-warning@-1 {{incompatible pointer to integer conversion casting 'char[1]' to type 'unsigned long'}}
+           // expected-error@-1 {{incompatible pointer to integer conversion casting 'char[1]' to type 'unsigned long'}}
       10);
 }
 
 void column_major_store(sx5x10_t *m1, ix3x2_t *m2, float *p1, int *p2, struct Foo *p3, const float *p4) {
   __builtin_matrix_column_major_store(*m1, p1, 1);
   // expected-error@-1 {{stride must be greater or equal to the number of rows}}
   __builtin_matrix_column_major_store(*m1, p1, 0);
   // expected-error@-1 {{stride must be greater or equal to the number of rows}}

clang/test/Sema/nullability.c

void arrays(int ints[_Nonnull],
             void * _Null_unspecified * _Nonnull nestedPtrs2[_Nullable],
             int fixedSize[_Nonnull 2],
             int staticSize[_Nonnull static 2],
             int staticSize2[static _Nonnull 2],
             int starSize[_Nonnull *],
             int vla[_Nonnull GLOBAL_LENGTH],
             void ** _Nullable reference);
 void testDecayedType(void) {
-  int produceAnErrorMessage = arrays; // expected-warning {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'void (int * _Nonnull, void ** _Nullable, void *** _Nullable, void * _Null_unspecified * _Nonnull * _Nullable, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, void ** _Nullable)'}}
+  int produceAnErrorMessage = arrays; // expected-error {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'void (int * _Nonnull, void ** _Nullable, void *** _Nullable, void * _Null_unspecified * _Nonnull * _Nullable, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, int * _Nonnull, void ** _Nullable)'}}
 }
 
 int notInFunction[_Nullable 3]; // expected-error {{nullability specifier '_Nullable' cannot be applied to non-pointer type 'int[3]'}}
 
 void nestedArrays(int x[5][_Nonnull 1]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[1]'}}
 void nestedArrays2(int x[5][_Nonnull 1][2]) {} // expected-error {{nullability specifier '_Nonnull' cannot be applied to non-pointer type 'int[1][2]'}}
 void nestedArraysOK(int x[_Nonnull 5][1]) {} // ok
 

clang/test/SemaObjC/argument-checking.m

 -structMeth:(struct S)s 
    :(struct S)s2; // expected-note{{passing argument to parameter 's2' here}}
 @end
 
 void test(void) {
   id obj = [Test alloc];
   struct S sInst;
 
-  charStarFunc(1); // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'char *'}}
-  charFunc("abc"); // expected-warning {{incompatible pointer to integer conversion passing 'char[4]' to parameter of type 'char'}}
+  charStarFunc(1); // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'char *'}}
+  charFunc("abc"); // expected-error {{incompatible pointer to integer conversion passing 'char[4]' to parameter of type 'char'}}
 
-  [obj charStarMeth:1]; // expected-warning {{incompatible integer to pointer conversion sending 'int'}}
+  [obj charStarMeth:1]; // expected-error {{incompatible integer to pointer conversion sending 'int'}}
   [obj structMeth:1]; // expected-error {{sending 'int'}}
   [obj structMeth:sInst :1]; // expected-error {{sending 'int'}}
 }

clang/test/SemaObjC/comptypes-7.m

int main(void)
   id obj = nil;
   id <MyProtocol> obj_p = nil;
   MyClass *obj_c = nil;
   Class obj_C = nil;
   
   int i = 0;
   int *j = nil;
 
-  /* These should all generate warnings.  */
+  /* The incompatible pointer types should all generate warnings, while the
+     incompatible integer to/from pointer conversions default to an error. */
   
-  obj = i; // expected-warning {{incompatible integer to pointer conversion assigning to 'id' from 'int'}}
+  obj = i; // expected-error {{incompatible integer to pointer conversion assigning to 'id' from 'int'}}
   obj = j; // expected-warning {{incompatible pointer types assigning to 'id' from 'int *'}}
 
-  obj_p = i; // expected-warning {{incompatible integer to pointer conversion assigning to 'id<MyProtocol>' from 'int'}}
+  obj_p = i; // expected-error {{incompatible integer to pointer conversion assigning to 'id<MyProtocol>' from 'int'}}
   obj_p = j; // expected-warning {{incompatible pointer types assigning to 'id<MyProtocol>' from 'int *'}}
   
-  obj_c = i; // expected-warning {{incompatible integer to pointer conversion assigning to 'MyClass *' from 'int'}}
+  obj_c = i; // expected-error {{incompatible integer to pointer conversion assigning to 'MyClass *' from 'int'}}
   obj_c = j; // expected-warning {{incompatible pointer types assigning to 'MyClass *' from 'int *'}}
 
-  obj_C = i; // expected-warning {{incompatible integer to pointer conversion assigning to 'Class' from 'int'}}
+  obj_C = i; // expected-error {{incompatible integer to pointer conversion assigning to 'Class' from 'int'}}
   obj_C = j; // expected-warning {{incompatible pointer types assigning to 'Class' from 'int *'}}
   
-  i = obj;   // expected-warning {{incompatible pointer to integer conversion assigning to 'int' from 'id'}}
-  i = obj_p; // expected-warning {{incompatible pointer to integer conversion assigning to 'int' from 'id<MyProtocol>'}}
-  i = obj_c; // expected-warning {{incompatible pointer to integer conversion assigning to 'int' from 'MyClass *'}}
-  i = obj_C; // expected-warning {{incompatible pointer to integer conversion assigning to 'int' from 'Class'}}
+  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-warning {{incompatible pointer types assigning to 'int *' from 'id'}}
   j = obj_p; // expected-warning {{incompatible pointer types assigning to 'int *' from 'id<MyProtocol>'}}
   j = obj_c; // expected-warning {{incompatible pointer types assigning to 'int *' from 'MyClass *'}}
   j = obj_C; // expected-warning {{incompatible pointer types assigning to 'int *' from 'Class'}}
   
   if (obj == i) foo() ; // expected-warning {{comparison between pointer and integer ('id' and 'int')}}
   if (i == obj) foo() ; // expected-warning {{comparison between pointer and integer ('int' and 'id')}}

clang/test/SemaObjC/ivar-lookup-resolution-builtin.m

 + (int) ClassMethod;
 @end
 
 @implementation Test1
 - (int) InstMethod
 {
   return index; // expected-error {{call to undeclared library function 'index'}} \
                 // expected-note {{include the header <strings.h> or explicitly provide a declaration for 'index'}} \
-                // expected-warning {{incompatible pointer to integer conversion returning}}
+                // expected-error {{incompatible pointer to integer conversion returning}}
 }
 + (int) ClassMethod
 {
-  return index; // expected-warning {{incompatible pointer to integer conversion returning}}
+  return index; // expected-error {{incompatible pointer to integer conversion returning}}
 }
 @end
 

clang/test/SemaObjC/message.m

 
 
 // PR3766
 struct S { int X; } S;
 
 int test5(int X) {
   int a = [X somemsg];  // expected-warning {{receiver type 'int' is not 'id'}} \
                            expected-warning {{method '-somemsg' not found}} \
-                           expected-warning {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'id'}}
+                           expected-error {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'id'}}
   int b = [S somemsg];  // expected-error {{bad receiver type 'struct S'}}
 }
 
 // PR4021
 void foo4(void) {
   struct objc_object X[10];
   
   [X rect]; // expected-warning {{receiver type 'struct objc_object *' is not 'id' or interface pointer, consider casting it to 'id'}}

clang/test/SemaObjC/method-lookup-5.m

 // RUN: %clang_cc1 -fsyntax-only -verify %s
 // rdar://8592156
 
 typedef struct objc_class *Class;
 @interface A
 -(Class) foo;
 @end
 
 void f0(A *a) { int x = [[a foo] baz]; } // expected-warning {{method '+baz' not found (return type defaults to 'id')}} \
-           // expected-warning {{ncompatible pointer to integer conversion initializing 'int' with an expression of type 'id'}}
+           // expected-error {{incompatible pointer to integer conversion initializing 'int' with an expression of type 'id'}}

clang/test/SemaObjC/nullability.m

 // Check that we don't propagate the nullability specifier on the receiver to
 // the result type of a message send if the result type cannot have a
 // nullability specifier.
 @interface C0
 -(int) count;
 @end
 
 void testMessageSendResultType(C0 * _Nullable c0) {
-  int *p = [c0 count]; // expected-warning {{incompatible integer to pointer conversion initializing 'int *' with an expression of type 'int'}}
+  int *p = [c0 count]; // expected-error {{incompatible integer to pointer conversion initializing 'int *' with an expression of type 'int'}}
 }

clang/test/SemaObjC/objc-container-subscripting-3.m

 int main(void) {
    Test *array;
    int i = array[10]; // expected-error {{method for accessing array element must have Objective-C object return type instead of 'int'}}
    array[2] = i;     // expected-error {{cannot assign to this array because assigning method's 2nd parameter of type 'int' is not an Objective-C pointer type}}
 
    NSMutableDictionary *dict;
    id key, val;
    val = dict[key]; // expected-error {{method for accessing dictionary element must have Objective-C object return type instead of 'int'}} \
-                    // expected-warning {{incompatible integer to pointer conversion assigning to 'id' from 'int'}}
+                    // expected-error {{incompatible integer to pointer conversion assigning to 'id' from 'int'}}
    dict[key] = val; // expected-error {{method object parameter type 'int' is not object type}}
 }
 

clang/test/SemaObjC/objc-literal-fixit.m

void test(void) {
 
   NSNumber *n5 = '\0'; // c-warning{{expression which evaluates to zero treated as a null pointer constant}}
                        // cxx-error@-1{{numeric literal must be prefixed by '@'}}
 
 
   NSNumber *n6 = '1'; // expected-error{{numeric literal must be prefixed by '@'}}
 
   int i;
-  NSNumber *n7 = i; // c-warning{{incompatible integer to pointer conversion}}
+  NSNumber *n7 = i; // c-error{{incompatible integer to pointer conversion}}
                     // arc-error@-1{{implicit conversion of 'int' to 'NSNumber *' is disallowed with ARC}}
                     // cxx-error@-2{{cannot initialize a variable of type 'NSNumber *' with an lvalue of type 'int'}}
 
-  id n8 = 1; // c-warning{{incompatible integer to pointer conversion}}
+  id n8 = 1; // c-error{{incompatible integer to pointer conversion}}
              // arc-error@-1{{implicit conversion of 'int' to 'id' is disallowed with ARC}}
              // cxx-error@-2{{cannot initialize a variable of type 'id' with an rvalue of type 'int'}}
 }

clang/test/SemaObjC/signed-char-bool-conversion.m

void t1(void) {
   b = i; // expected-warning {{implicit conversion from integral type 'int' to 'BOOL'}}
 
   b = 1.0;
   b = 0.0;
   b = 1.1; // expected-warning {{implicit conversion from 'double' to 'BOOL' (aka 'signed char') changes value from 1.1 to 1}}
   b = 2.1; // expected-warning {{implicit conversion from constant value 2.1 to 'BOOL'; the only well defined values for 'BOOL' are YES and NO}}
 
   b = YES;
-#ifndef __cplusplus
-  b = ptr; // expected-warning {{incompatible pointer to integer conversion assigning to 'BOOL' (aka 'signed char') from 'int *'}}
-#endif
+  b = ptr; // expected-error {{incompatible pointer to integer conversion assigning to 'BOOL' (aka 'signed char') from 'int *'}}
 }
 
 @interface BoolProp
 @property BOOL p;
 @end
 
 void t2(BoolProp *bp) {
   bp.p = YES;
   bp.p = NO;
   bp.p = boolean;
   bp.p = fl; // expected-warning {{implicit conversion from floating-point type 'float' to 'BOOL'}}
   bp.p = i; // expected-warning {{implicit conversion from integral type 'int' to 'BOOL'}}
   bp.p = b;
   bp.p = bp.p;
-#ifndef __cplusplus
-  bp.p = ptr; // expected-warning {{incompatible pointer to integer conversion assigning to 'BOOL' (aka 'signed char') from 'int *'}}
-#endif
+  bp.p = ptr; // expected-error {{incompatible pointer to integer conversion assigning to 'BOOL' (aka 'signed char') from 'int *'}}
   bp.p = 1;
   bp.p = 2; // expected-warning {{implicit conversion from constant value 2 to 'BOOL'; the only well defined values for 'BOOL' are YES and NO}}
 }
 
 struct has_bf {
   int signed_bf1 : 1;
   int signed_bf2 : 2;
   unsigned unsigned_bf1 : 1;

clang/test/SemaOpenCL/atomic-ops.cl

void f(atomic_int *i, const atomic_int *ci,
   // Pointers to different address spaces are allowed.
   bool cmpexch_10 = __opencl_atomic_compare_exchange_strong((global atomic_int *)0x308, (constant int *)0x309, 1, memory_order_seq_cst, memory_order_seq_cst, memory_scope_work_group);
 
   __opencl_atomic_init(ci, 0); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const __generic atomic_int *' (aka 'const __generic _Atomic(int) *') invalid)}}
   __opencl_atomic_store(ci, 0, memory_order_release, memory_scope_work_group); // expected-error {{address argument to atomic operation must be a pointer to non-const _Atomic type ('const __generic atomic_int *' (aka 'const __generic _Atomic(int) *') invalid)}}
   __opencl_atomic_load(ci, memory_order_acquire, memory_scope_work_group);
 
   __opencl_atomic_init(&gn, 456);
-  __opencl_atomic_init(&gn, (void*)0); // expected-warning{{incompatible pointer to integer conversion passing '__generic void *' to parameter of type 'int'}}
+  __opencl_atomic_init(&gn, (void*)0); // expected-error{{incompatible pointer to integer conversion passing '__generic void *' to parameter of type 'int'}}
 }
 
 void memory_checks(atomic_int *Ap, int *p, int val) {
   // non-integer memory order argument is casted to integer type.
   (void)__opencl_atomic_load(Ap, 1.0f, memory_scope_work_group);
   float forder;
   (void)__opencl_atomic_load(Ap, forder, memory_scope_work_group);
   struct S s;

clang/test/SemaOpenCL/builtins-amdgcn-error.cl

 }
 
 void test_fence() {
   __builtin_amdgcn_fence(__ATOMIC_SEQ_CST + 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   __builtin_amdgcn_fence(__ATOMIC_ACQUIRE - 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   __builtin_amdgcn_fence(4); // expected-error {{too few arguments to function call, expected 2}}
   __builtin_amdgcn_fence(4, 4, 4); // expected-error {{too many arguments to function call, expected 2}}
   __builtin_amdgcn_fence(3.14, ""); // expected-warning {{implicit conversion from 'double' to 'unsigned int' changes value from 3.14 to 3}}
-  __builtin_amdgcn_fence(__ATOMIC_ACQUIRE, 5); // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
+  __builtin_amdgcn_fence(__ATOMIC_ACQUIRE, 5); // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
   const char ptr[] = "workgroup";
   __builtin_amdgcn_fence(__ATOMIC_ACQUIRE, ptr); // expected-error {{expression is not a string literal}}
 }
 
 void test_s_setreg(int x, int y) {
   __builtin_amdgcn_s_setreg(x, 0); // expected-error {{argument to '__builtin_amdgcn_s_setreg' must be a constant integer}}
   __builtin_amdgcn_s_setreg(x, y); // expected-error {{argument to '__builtin_amdgcn_s_setreg' must be a constant integer}}
 }
 
 void test_atomic_inc32() {
   uint val = 17;
   val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_SEQ_CST + 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_RELAXED, "workgroup");
   val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_CONSUME, "workgroup");
   val = __builtin_amdgcn_atomic_inc32(4);                                            // expected-error {{too few arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_inc32(&val, val, 4, 4, 4, 4);                        // expected-error {{too many arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_inc32(&val, val, 3.14, "");                          // expected-warning {{implicit conversion from 'double' to 'unsigned int' changes value from 3.14 to 3}}
-  val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
+  val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
   const char ptr[] = "workgroup";
   val = __builtin_amdgcn_atomic_inc32(&val, val, __ATOMIC_ACQUIRE, ptr); // expected-error {{expression is not a string literal}}
   int signedVal = 15;
   signedVal = __builtin_amdgcn_atomic_inc32(&signedVal, signedVal, __ATOMIC_ACQUIRE, ""); // expected-warning {{passing '__private int *' to parameter of type 'volatile __private unsigned int *' converts between pointers to integer types with different sign}}
 }
 
 void test_atomic_inc64() {
   __UINT64_TYPE__ val = 17;
   val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_SEQ_CST + 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_RELAXED, "workgroup");
   val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_CONSUME, "workgroup");
   val = __builtin_amdgcn_atomic_inc64(4);                                            // expected-error {{too few arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_inc64(&val, val, 4, 4, 4, 4);                        // expected-error {{too many arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_inc64(&val, val, 3.14, "");                          // expected-warning {{implicit conversion from 'double' to 'unsigned int' changes value from 3.14 to 3}}
-  val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
+  val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
   const char ptr[] = "workgroup";
   val = __builtin_amdgcn_atomic_inc64(&val, val, __ATOMIC_ACQUIRE, ptr); // expected-error {{expression is not a string literal}}
   __INT64_TYPE__ signedVal = 15;
   signedVal = __builtin_amdgcn_atomic_inc64(&signedVal, signedVal, __ATOMIC_ACQUIRE, ""); // expected-warning {{passing '__private long *' to parameter of type 'volatile __private unsigned long *' converts between pointers to integer types with different sign}}
 }
 
 void test_atomic_dec32() {
   uint val = 17;
   val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_SEQ_CST + 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_RELAXED, "workgroup");
   val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_CONSUME, "workgroup");
   val = __builtin_amdgcn_atomic_dec32(4);                                            // expected-error {{too few arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_dec32(&val, val, 4, 4, 4, 4);                        // expected-error {{too many arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_dec32(&val, val, 3.14, "");                          // expected-warning {{implicit conversion from 'double' to 'unsigned int' changes value from 3.14 to 3}}
-  val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
+  val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
   const char ptr[] = "workgroup";
   val = __builtin_amdgcn_atomic_dec32(&val, val, __ATOMIC_ACQUIRE, ptr); // expected-error {{expression is not a string literal}}
   int signedVal = 15;
   signedVal = __builtin_amdgcn_atomic_dec32(&signedVal, signedVal, __ATOMIC_ACQUIRE, ""); // expected-warning {{passing '__private int *' to parameter of type 'volatile __private unsigned int *' converts between pointers to integer types with different sign}}
 }
 
 void test_atomic_dec64() {
   __UINT64_TYPE__ val = 17;
   val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_SEQ_CST + 1, "workgroup"); // expected-warning {{memory order argument to atomic operation is invalid}}
   val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_RELAXED, "workgroup");
   val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_CONSUME, "workgroup");
   val = __builtin_amdgcn_atomic_dec64(4);                                            // expected-error {{too few arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_dec64(&val, val, 4, 4, 4, 4);                        // expected-error {{too many arguments to function call, expected 4}}
   val = __builtin_amdgcn_atomic_dec64(&val, val, 3.14, "");                          // expected-warning {{implicit conversion from 'double' to 'unsigned int' changes value from 3.14 to 3}}
-  val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-warning {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
+  val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_ACQUIRE, 5);               // expected-error {{incompatible integer to pointer conversion passing 'int' to parameter of type 'const char *'}}
   const char ptr[] = "workgroup";
   val = __builtin_amdgcn_atomic_dec64(&val, val, __ATOMIC_ACQUIRE, ptr); // expected-error {{expression is not a string literal}}
   __INT64_TYPE__ signedVal = 15;
   signedVal = __builtin_amdgcn_atomic_dec64(&signedVal, signedVal, __ATOMIC_ACQUIRE, ""); // expected-warning {{passing '__private long *' to parameter of type 'volatile __private unsigned long *' converts between pointers to integer types with different sign}}
 }

clang/test/VFS/Inputs/external-names.h

 void foo(char **c) {
   *c = __FILE__;
-  int x = c; // produce a diagnostic
+  const char **x = c; // produce a diagnostic
 }

clang/test/VFS/external-names.c

 
 // RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -E %s | FileCheck -check-prefix=CHECK-PP %s
 // CHECK-PP-NOT: Inputs
 
 ////
 // Diagnostics:
 
 // RUN: %clang_cc1 -I %t -ivfsoverlay %t.external.yaml -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-DIAG-EXTERNAL %s
-// CHECK-DIAG-EXTERNAL: {{.*}}Inputs{{..?}}external-names.h:{{[0-9]*:[0-9]*}}: warning: incompatible pointer
+// CHECK-DIAG-EXTERNAL: {{.*}}Inputs{{..?}}external-names.h:{{[0-9]*:[0-9]*}}: warning: initializing 'const char **'
 
 // RUN: %clang_cc1 -I %t -ivfsoverlay %t.yaml -fsyntax-only %s 2>&1 | FileCheck -check-prefix=CHECK-DIAG %s
 // CHECK-DIAG-NOT: Inputs
 
 ////
 // Debug info
 
 // RUN: %clang_cc1 -I %t -ivfsoverlay %t.external.yaml -triple %itanium_abi_triple -debug-info-kind=limited -emit-llvm %s -o - | FileCheck -check-prefix=CHECK-DEBUG-EXTERNAL %s

compiler-rt/test/dfsan/gep.c

-// RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -o %t && %run %t
-// RUN: %clang_dfsan %s -DPROP_OFFSET_LABELS -o %t && %run %t
+// RUN: %clang_dfsan %s -mllvm -dfsan-combine-offset-labels-on-gep=false -Wno-error=int-conversion -o %t && %run %t
+// RUN: %clang_dfsan %s -DPROP_OFFSET_LABELS -Wno-error=int-conversion -o %t && %run %t
 //
 // REQUIRES: x86_64-target-arch
 
 // Tests that labels are propagated through GEP.
 
 #include <sanitizer/dfsan_interface.h>
 #include <assert.h>
 

compiler-rt/test/dfsan/sigaction.c

-// RUN: %clang_dfsan -DUSE_SIGNAL_ACTION %s -o %t && %run %t
-// RUN: %clang_dfsan %s -o %t && %run %t
+// RUN: %clang_dfsan -DUSE_SIGNAL_ACTION -Wno-error=int-conversion %s -o %t && %run %t
+// RUN: %clang_dfsan -Wno-error=int-conversion %s -o %t && %run %t
 //
 // REQUIRES: x86_64-target-arch
 
 #include <sanitizer/dfsan_interface.h>
 
 #include <assert.h>
 #include <signal.h>
 #include <string.h>