Fix the spelling of 'bitfield' in diagnostics to be consistently 'bit-field'.

[chandlerc]

Summary

The latter agrees with most existing diagnostics and the C and C++ standards.

[chandlerc]

Update the tests accordingly.

[chandlerc]

Rebase and ping? It'd be awesome to land this minor patch, its been out for a month now.

[aaron.ballman]

LGTM! This is the way it is spelled in the C and C++ standards as well.

cfe/trunk/include/clang/Basic/DiagnosticParseKinds.td

 def err_objc_expected_equal_for_getter : Error<
   "expected '=' for Objective-C getter">;
 def err_objc_expected_equal_for_setter : Error<
   "expected '=' for Objective-C setter">;
 def err_objc_expected_selector_for_getter_setter : Error<
   "expected selector for Objective-C %select{setter|getter}0">;
 def err_objc_property_requires_field_name : Error<
   "property requires fields to be named">;
-def err_objc_property_bitfield : Error<"property name cannot be a bitfield">;
+def err_objc_property_bitfield : Error<"property name cannot be a bit-field">;
 def err_objc_expected_property_attr : Error<"unknown property attribute %0">;
 def err_objc_properties_require_objc2 : Error<
   "properties are an Objective-C 2 feature">;
 def err_objc_unexpected_attr : Error<
   "prefix attribute must be followed by an interface or protocol">;
 def err_objc_postfix_attribute : Error <
   "postfix attributes are not allowed on Objective-C directives">;
 def err_objc_postfix_attribute_hint : Error <

 // C++11 in-class member initialization
 def ext_nonstatic_member_init : ExtWarn<
   "in-class initialization of non-static data member is a C++11 extension">,
   InGroup<CXX11>;
 def warn_cxx98_compat_nonstatic_member_init : Warning<
   "in-class initialization of non-static data members is incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_bitfield_member_init: Error<
-  "bitfield member cannot have an in-class initializer">;
+  "bit-field member cannot have an in-class initializer">;
 def err_incomplete_array_member_init: Error<
   "array bound cannot be deduced from an in-class initializer">;
 
 // C++11 alias-declaration
 def ext_alias_declaration : ExtWarn<
   "alias declarations are a C++11 extension">, InGroup<CXX11>;
 def warn_cxx98_compat_alias_declaration : Warning<
   "alias declarations are incompatible with C++98">,

cfe/trunk/include/clang/Basic/DiagnosticSemaKinds.td

def warn_impcast_integer_precision : Warning<
   InGroup<Conversion>, DefaultIgnore;
 def warn_impcast_integer_64_32 : Warning<
   "implicit conversion loses integer precision: %0 to %1">,
   InGroup<Shorten64To32>, DefaultIgnore;
 def warn_impcast_integer_precision_constant : Warning<
   "implicit conversion from %2 to %3 changes value from %0 to %1">,
   InGroup<ConstantConversion>;
 def warn_impcast_bitfield_precision_constant : Warning<
-  "implicit truncation from %2 to bitfield changes value from %0 to %1">,
+  "implicit truncation from %2 to bit-field changes value from %0 to %1">,
   InGroup<BitFieldConstantConversion>;
 
 def warn_impcast_literal_float_to_integer : Warning<
   "implicit conversion from %0 to %1 changes value from %2 to %3">,
   InGroup<LiteralConversion>;
 def warn_impcast_float_integer : Warning<
   "implicit conversion turns floating-point number into integer: %0 to %1">,
   InGroup<FloatConversion>, DefaultIgnore;

 def err_kernel_arg_address_space : Error<
   "pointer arguments to kernel functions must reside in '__global', "
   "'__constant' or '__local' address space">;
 def err_opencl_function_variable : Error<
   "%select{non-kernel function|function scope}0 variable cannot be declared in %1 address space">;
 def err_static_function_scope : Error<
   "variables in function scope cannot be declared static">;
 def err_opencl_bitfields : Error<
-  "bitfields are not supported in OpenCL">;
+  "bit-fields are not supported in OpenCL">;
 def err_opencl_vla : Error<
   "variable length arrays are not supported in OpenCL">;
 def err_bad_kernel_param_type : Error<
   "%0 cannot be used as the type of a kernel parameter">;
 def err_record_with_pointers_kernel_param : Error<
   "%select{struct|union}0 kernel parameters may not contain pointers">;
 def note_within_field_of_type : Note<
   "within field of type %0 declared here">;

cfe/trunk/test/Parser/objc-property-syntax.m

 // RUN: %clang_cc1 -fsyntax-only -verify -Wno-objc-root-class %s
 
 @interface MyClass {
   int prop;
 };
 @property unsigned char bufferedUTF8Bytes[4];  // expected-error {{property cannot have array or function type}}
-@property unsigned char bufferedUTFBytes:1;    // expected-error {{property name cannot be a bitfield}}
+@property unsigned char bufferedUTFBytes:1;    // expected-error {{property name cannot be a bit-field}}
 @property(nonatomic, retain, setter=ab_setDefaultToolbarItems) MyClass *ab_defaultToolbarItems; // expected-error {{method name referenced in property setter attribute must end with ':'}}
 
 @property int prop;
 @end
 
 @implementation MyClass
 @dynamic ab_defaultToolbarItems // expected-error{{expected ';' after @dynamic}}
 @synthesize prop // expected-error{{expected ';' after @synthesize}}
 @end
 

cfe/trunk/test/Sema/constant-conversion.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-apple-darwin %s
 
 // This file tests -Wconstant-conversion, a subcategory of -Wconversion
 // which is on by default.
 
 // rdar://problem/6792488
 void test_6792488(void) {
   int x = 0x3ff0000000000000U; // expected-warning {{implicit conversion from 'unsigned long' to 'int' changes value from 4607182418800017408 to 0}}
 }
 
 void test_7809123(void) {
   struct { int i5 : 5; } a;
 
-  a.i5 = 36; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 36 to 4}}
+  a.i5 = 36; // expected-warning {{implicit truncation from 'int' to bit-field changes value from 36 to 4}}
 }
 
 void test() {
   struct { int bit : 1; } a;
   a.bit = 1; // shouldn't warn
 }
 
 enum Test2 { K_zero, K_one };
 enum Test2 test2(enum Test2 *t) {
   *t = 20;
   return 10; // shouldn't warn
 }
 
 void test3() {
   struct A {
     unsigned int foo : 2;
     int bar : 2;
   };
 
-  struct A a = { 0, 10 };            // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to -2}}
-  struct A b[] = { 0, 10, 0, 0 };    // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to -2}}
-  struct A c[] = {{10, 0}};          // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}}
-  struct A d = (struct A) { 10, 0 }; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}}
-  struct A e = { .foo = 10 };        // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}}
+  struct A a = { 0, 10 };            // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to -2}}
+  struct A b[] = { 0, 10, 0, 0 };    // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to -2}}
+  struct A c[] = {{10, 0}};          // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to 2}}
+  struct A d = (struct A) { 10, 0 }; // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to 2}}
+  struct A e = { .foo = 10 };        // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to 2}}
 }
 
 void test4() {
   struct A {
     char c : 2;
   } a;
 
-  a.c = 0x101; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 257 to 1}}
+  a.c = 0x101; // expected-warning {{implicit truncation from 'int' to bit-field changes value from 257 to 1}}
 }
 
 void test5() {
   struct A {
     _Bool b : 1;
   } a;
 
   // Don't warn about this implicit conversion to bool, or at least
-  // don't warn about it just because it's a bitfield.
+  // don't warn about it just because it's a bit-field.
   a.b = 100;
 }
 
 void test6() {
   // Test that unreachable code doesn't trigger the truncation warning.
   unsigned char x = 0 ? 65535 : 1; // no-warning
   unsigned char y = 1 ? 65535 : 1; // expected-warning {{changes value}}
 }
 
 void test7() {
   struct {
     unsigned int twoBits1:2;
     unsigned int twoBits2:2;
     unsigned int reserved:28;
   } f;
 
   f.twoBits1 = ~0; // no-warning
   f.twoBits1 = ~1; // no-warning
-  f.twoBits2 = ~2; // expected-warning {{implicit truncation from 'int' to bitfield changes value from -3 to 1}}
+  f.twoBits2 = ~2; // expected-warning {{implicit truncation from 'int' to bit-field changes value from -3 to 1}}
   f.twoBits1 &= ~1; // no-warning
   f.twoBits2 &= ~2; // no-warning
 }
 
 void test8() {
   enum E { A, B, C };
   struct { enum E x : 1; } f;
-  f.x = C; // expected-warning {{implicit truncation from 'int' to bitfield changes value from 2 to 0}}
+  f.x = C; // expected-warning {{implicit truncation from 'int' to bit-field changes value from 2 to 0}}
 }
 
 void test9() {
   const char max_char = 0x7F;
   const short max_short = 0x7FFF;
   const int max_int = 0x7FFFFFFF;
 
   const short max_char_plus_one = (short)max_char + 1;
void test10() {
   } s;
   s.a = -1;
   s.a = 15;
   s.a = -8;
   s.a = ~0;
   s.a = ~0U;
   s.a = ~(1<<A);
 
-  s.a = -9;  // expected-warning{{implicit truncation from 'int' to bitfield changes value from -9 to 7}}
-  s.a = 16;  // expected-warning{{implicit truncation from 'int' to bitfield changes value from 16 to 0}}
+  s.a = -9;  // expected-warning{{implicit truncation from 'int' to bit-field changes value from -9 to 7}}
+  s.a = 16;  // expected-warning{{implicit truncation from 'int' to bit-field changes value from 16 to 0}}
 }

cfe/trunk/test/SemaCXX/conversion.cpp

namespace test1 {
   bool test2(void *p) {
     return p == foo();
   }
 }
 
 namespace test2 {
   struct A {
     unsigned int x : 2;
-    A() : x(10) {} // expected-warning {{implicit truncation from 'int' to bitfield changes value from 10 to 2}}
+    A() : x(10) {} // expected-warning {{implicit truncation from 'int' to bit-field changes value from 10 to 2}}
   };
 }
 
 // This file tests -Wnull-conversion, a subcategory of -Wconversion
 // which is on by default.
 
 void test3() {
   int a = NULL; // expected-warning {{implicit conversion of NULL constant to 'int'}}

cfe/trunk/test/SemaCXX/member-init.cpp

 // RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s
 
 struct Bitfield {
-  int n : 3 = 7; // expected-error {{bitfield member cannot have an in-class initializer}}
+  int n : 3 = 7; // expected-error {{bit-field member cannot have an in-class initializer}}
 };
 
 int a;
 class NoWarning {
   int &n = a;
 public:
   int &GetN() { return n; }
 };

cfe/trunk/test/SemaOpenCL/unsupported.cl

 // RUN: %clang_cc1 -verify %s
 
 struct {
-  int a : 1; // expected-error {{bitfields are not supported in OpenCL}}
+  int a : 1; // expected-error {{bit-fields are not supported in OpenCL}}
 };
 
 void no_vla(int n) {
   int a[n]; // expected-error {{variable length arrays are not supported in OpenCL}}
 }
 
 void no_logxor(int n) {
   int logxor = n ^^ n; // expected-error {{^^ is a reserved operator in OpenCL}}
 }