Replace "can not" with "cannot" in diagnostics messages.

llvm-svn: 203302

clang/include/clang/Basic/DiagnosticParseKinds.td

@@ -193,7 +193,7 @@ def err_expected_semi_after_method_proto : Error<
 def err_expected_semi_after_namespace_name : Error<
   "expected ';' after namespace name">;
 def err_unexpected_namespace_attributes_alias : Error<
-  "attributes can not be specified on namespace alias">;
+  "attributes cannot be specified on namespace alias">;
 def err_inline_namespace_alias : Error<"namespace alias cannot be inline">;
 def err_namespace_nonnamespace_scope : Error<
   "namespaces can only be defined in global or namespace scope">;
@@ -412,7 +412,7 @@ def err_objc_concat_string : Error<"unexpected token after Objective-C string">;
 def err_expected_objc_container : Error<
   "'@end' must appear in an Objective-C context">;
 def err_unexpected_protocol_qualifier : Error<
-  "@implementation declaration can not be protocol qualified">;
+  "@implementation declaration cannot be protocol qualified">;
 def err_objc_unexpected_atend : Error<
   "'@end' appears where closing brace '}' is expected">;
 def error_property_ivar_decl : Error<

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -106,9 +106,9 @@ def err_array_star_in_function_definition : Error<
 def err_vla_decl_in_file_scope : Error<
   "variable length array declaration not allowed at file scope">;
 def err_vla_decl_has_static_storage : Error<
-  "variable length array declaration can not have 'static' storage duration">;
+  "variable length array declaration cannot have 'static' storage duration">;
 def err_vla_decl_has_extern_linkage : Error<
-  "variable length array declaration can not have 'extern' linkage">;
+  "variable length array declaration cannot have 'extern' linkage">;
 def ext_vla_folded_to_constant : Extension<
   "variable length array folded to constant array as an extension">, InGroup<GNUFoldingConstant>;
 
@@ -273,9 +273,9 @@ def err_using_decl_nested_name_specifier_is_current_class : Error<
 def err_using_decl_nested_name_specifier_is_not_base_class : Error<
   "using declaration refers into '%0', which is not a base class of %1">;
 def err_using_decl_constructor_not_in_direct_base : Error<
-  "%0 is not a direct base of %1, can not inherit constructors">;
+  "%0 is not a direct base of %1, cannot inherit constructors">;
 def err_using_decl_constructor_conflict : Error<
-  "can not inherit constructor, already inherited constructor with "
+  "cannot inherit constructor, already inherited constructor with "
   "the same signature">;
 def note_using_decl_constructor_conflict_current_ctor : Note<
   "conflicting constructor">;
@@ -289,18 +289,18 @@ def warn_using_decl_constructor_ellipsis : Warning<
 def note_using_decl_constructor_ellipsis : Note<
   "constructor declared with ellipsis here">;
 def err_using_decl_can_not_refer_to_class_member : Error<
-  "using declaration can not refer to class member">;
+  "using declaration cannot refer to class member">;
 def err_using_decl_can_not_refer_to_namespace : Error<
-  "using declaration can not refer to namespace">;
+  "using declaration cannot refer to namespace">;
 def err_using_decl_constructor : Error<
-  "using declaration can not refer to a constructor">;
+  "using declaration cannot refer to a constructor">;
 def warn_cxx98_compat_using_decl_constructor : Warning<
   "inheriting constructors are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_using_decl_destructor : Error<
-  "using declaration can not refer to a destructor">;
+  "using declaration cannot refer to a destructor">;
 def err_using_decl_template_id : Error<
-  "using declaration can not refer to a template specialization">;
+  "using declaration cannot refer to a template specialization">;
 def note_using_decl_target : Note<"target of using declaration">;
 def note_using_decl_conflict : Note<"conflicting declaration">;
 def err_using_decl_redeclaration : Error<"redeclaration of using decl">;
@@ -861,7 +861,7 @@ def error_weak_property : Error<
 def error_strong_property : Error<
   "existing instance variable %1 for strong property %0 may not be __weak">;
 def error_dynamic_property_ivar_decl : Error<
-  "dynamic property can not have instance variable specification">;
+  "dynamic property cannot have instance variable specification">;
 def error_duplicate_ivar_use : Error<
   "synthesized properties %0 and %1 both claim instance variable %2">;
 def error_property_implemented : Error<"property %0 is already implemented">;
@@ -986,13 +986,13 @@ def err_multiple_final_overriders : Error<
 def note_final_overrider : Note<"final overrider of %q0 in %1">;
 
 def err_type_defined_in_type_specifier : Error<
-  "%0 can not be defined in a type specifier">;
+  "%0 cannot be defined in a type specifier">;
 def err_type_defined_in_result_type : Error<
-  "%0 can not be defined in the result type of a function">;
+  "%0 cannot be defined in the result type of a function">;
 def err_type_defined_in_param_type : Error<
-  "%0 can not be defined in a parameter type">;
+  "%0 cannot be defined in a parameter type">;
 def err_type_defined_in_alias_template : Error<
-  "%0 can not be defined in a type alias template">;
+  "%0 cannot be defined in a type alias template">;
 
 def note_pure_virtual_function : Note<
   "unimplemented pure virtual method %0 in %1">;
@@ -1162,7 +1162,7 @@ def err_virtual_non_function : Error<
 def err_virtual_out_of_class : Error<
   "'virtual' can only be specified inside the class definition">;
 def err_virtual_member_function_template : Error<
-  "'virtual' can not be specified on member function templates">;
+  "'virtual' cannot be specified on member function templates">;
 def err_static_overrides_virtual : Error<
   "'static' member function %0 overrides a virtual function in a base class">;
 def err_explicit_non_function : Error<
@@ -3255,7 +3255,7 @@ def err_partial_spec_args_match_primary_template : Error<
     "primary template, remove the template argument list">; 
 def warn_partial_specs_not_deducible : Warning<
     "%select{class|variable}0 template partial specialization contains "
-    "%select{a template parameter|template parameters}1 that can not be "
+    "%select{a template parameter|template parameters}1 that cannot be "
     "deduced; this partial specialization will never be used">;
 def note_partial_spec_unused_parameter : Note<
     "non-deducible template parameter %0">;
@@ -3785,7 +3785,7 @@ def warn_illegal_constant_array_size : Extension<
 def err_vm_decl_in_file_scope : Error<
   "variably modified type declaration not allowed at file scope">;
 def err_vm_decl_has_extern_linkage : Error<
-  "variably modified type declaration can not have 'extern' linkage">;
+  "variably modified type declaration cannot have 'extern' linkage">;
 def err_typecheck_field_variable_size : Error<
   "fields must have a constant size: 'variable length array in structure' "
   "extension will never be supported">;
@@ -4910,7 +4910,7 @@ def warn_register_objc_catch_parm : Warning<
 def err_qualified_objc_catch_parm : Error<
   "@catch parameter declarator cannot be qualified">;
 def warn_objc_pointer_cxx_catch_fragile : Warning<
-  "can not catch an exception thrown with @throw in C++ in the non-unified "
+  "cannot catch an exception thrown with @throw in C++ in the non-unified "
   "exception model">, InGroup<ObjCNonUnifiedException>;
 def err_objc_object_catch : Error<
   "can't catch an Objective-C object by value">;

clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp

@@ -7,6 +7,6 @@ struct A {
 };
 
 struct B : A {
-  using A::f<double>; // expected-error{{using declaration can not refer to a template specialization}}
-  using A::X<int>; // expected-error{{using declaration can not refer to a template specialization}}
+  using A::f<double>; // expected-error{{using declaration cannot refer to a template specialization}}
+  using A::X<int>; // expected-error{{using declaration cannot refer to a template specialization}}
 };

clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp

@@ -5,4 +5,4 @@ namespace A {
   namespace B { }
 }
 
-using A::B; // expected-error{{using declaration can not refer to namespace}}
+using A::B; // expected-error{{using declaration cannot refer to namespace}}

clang/test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp

@@ -6,10 +6,10 @@ struct X {
   static int a;
 };
 
-using X::i; // expected-error{{using declaration can not refer to class member}}
-using X::s; // expected-error{{using declaration can not refer to class member}}
+using X::i; // expected-error{{using declaration cannot refer to class member}}
+using X::s; // expected-error{{using declaration cannot refer to class member}}
 
 void f() {
-  using X::i; // expected-error{{using declaration can not refer to class member}}
-  using X::s; // expected-error{{using declaration can not refer to class member}}
+  using X::i; // expected-error{{using declaration cannot refer to class member}}
+  using X::s; // expected-error{{using declaration cannot refer to class member}}
 }

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/p3-0x.cpp

@@ -2,12 +2,12 @@
 
 using X = struct { // ok
 };
-template<typename T> using Y = struct { // expected-error {{can not be defined in a type alias template}}
+template<typename T> using Y = struct { // expected-error {{cannot be defined in a type alias template}}
 };
 
 class K {
   virtual ~K();
-  operator struct S {} (); // expected-error{{'K::S' can not be defined in a type specifier}}
+  operator struct S {} (); // expected-error{{'K::S' cannot be defined in a type specifier}}
 };
 
 struct A {};
@@ -18,26 +18,26 @@ void f() {
   for (struct S { S(int) {} } s : arr) { // expected-error {{types may not be defined in a for range declaration}}
   }
 
-  new struct T {}; // expected-error {{'T' can not be defined in a type specifier}}
-  new struct A {}; // expected-error {{'A' can not be defined in a type specifier}}
+  new struct T {}; // expected-error {{'T' cannot be defined in a type specifier}}
+  new struct A {}; // expected-error {{'A' cannot be defined in a type specifier}}
 
-  try {} catch (struct U {}) {} // expected-error {{'U' can not be defined in a type specifier}}
+  try {} catch (struct U {}) {} // expected-error {{'U' cannot be defined in a type specifier}}
 
-  (void)(struct V { V(int); })0; // expected-error {{'V' can not be defined in a type specifier}}
+  (void)(struct V { V(int); })0; // expected-error {{'V' cannot be defined in a type specifier}}
 
-  (void)dynamic_cast<struct W {}*>((K*)0); // expected-error {{'W' can not be defined in a type specifier}}
-  (void)static_cast<struct X {}*>(0); // expected-error {{'X' can not be defined in a type specifier}}
-  (void)reinterpret_cast<struct Y {}*>(0); // expected-error {{'Y' can not be defined in a type specifier}}
-  (void)const_cast<struct Z {}*>((const Z*)0); // expected-error {{'Z' can not be defined in a type specifier}}
+  (void)dynamic_cast<struct W {}*>((K*)0); // expected-error {{'W' cannot be defined in a type specifier}}
+  (void)static_cast<struct X {}*>(0); // expected-error {{'X' cannot be defined in a type specifier}}
+  (void)reinterpret_cast<struct Y {}*>(0); // expected-error {{'Y' cannot be defined in a type specifier}}
+  (void)const_cast<struct Z {}*>((const Z*)0); // expected-error {{'Z' cannot be defined in a type specifier}}
 }
 
-void g() throw (struct Ex {}) { // expected-error {{'Ex' can not be defined in a type specifier}}
+void g() throw (struct Ex {}) { // expected-error {{'Ex' cannot be defined in a type specifier}}
 }
 
-alignas(struct Aa {}) int x; // expected-error {{'Aa' can not be defined in a type specifier}}
+alignas(struct Aa {}) int x; // expected-error {{'Aa' cannot be defined in a type specifier}}
 
-int a = sizeof(struct So {}); // expected-error {{'So' can not be defined in a type specifier}}
-int b = alignof(struct Ao {}); // expected-error {{'Ao' can not be defined in a type specifier}}
+int a = sizeof(struct So {}); // expected-error {{'So' cannot be defined in a type specifier}}
+int b = alignof(struct Ao {}); // expected-error {{'Ao' cannot be defined in a type specifier}}
 
 namespace std { struct type_info; }
-const std::type_info &ti = typeid(struct Ti {}); // expected-error {{'Ti' can not be defined in a type specifier}}
+const std::type_info &ti = typeid(struct Ti {}); // expected-error {{'Ti' cannot be defined in a type specifier}}

clang/test/CXX/dcl.decl/dcl.meaning/dcl.fct/p8.cpp

@@ -1,8 +1,8 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 struct A { };
-A::A (enum { e1 }) {} // expected-error{{can not be defined in a parameter}}
-void A::f(enum { e2 }) {} // expected-error{{can not be defined in a parameter}}
+A::A (enum { e1 }) {} // expected-error{{cannot be defined in a parameter}}
+void A::f(enum { e2 }) {} // expected-error{{cannot be defined in a parameter}}
 
-enum { e3 } A::g() { } // expected-error{{can not be defined in the result type}} \
+enum { e3 } A::g() { } // expected-error{{cannot be defined in the result type}} \
 // expected-error{{out-of-line definition}}

clang/test/CXX/drs/dr1xx.cpp

@@ -66,7 +66,7 @@ namespace dr108 { // dr108: yes
 namespace dr109 { // dr109: yes
   struct A { template<typename T> void f(T); };
   template<typename T> struct B : T {
-    using T::template f; // expected-error {{using declaration can not refer to a template}}
+    using T::template f; // expected-error {{using declaration cannot refer to a template}}
     void g() { this->f<int>(123); } // expected-error {{use 'template'}}
   };
 }
@@ -722,9 +722,9 @@ namespace dr169 { // dr169: yes
   };
   struct D : A<int>, B {
     using A<int>::n;
-    using B::C<int>; // expected-error {{using declaration can not refer to a template specialization}}
-    using B::f<int>; // expected-error {{using declaration can not refer to a template specialization}}
-    using B::n<int>; // expected-error {{using declaration can not refer to a template specialization}}
+    using B::C<int>; // expected-error {{using declaration cannot refer to a template specialization}}
+    using B::f<int>; // expected-error {{using declaration cannot refer to a template specialization}}
+    using B::n<int>; // expected-error {{using declaration cannot refer to a template specialization}}
   };
 }
 

clang/test/CXX/special/class.inhctor/elsewhere.cpp

@@ -9,7 +9,7 @@ struct B1 {
   B1(int);
 };
 
-using B1::B1; // expected-error {{using declaration can not refer to class member}}
+using B1::B1; // expected-error {{using declaration cannot refer to class member}}
 
 // C++11 [namespace.udecl]p10:
 //   A using-declaration is a declaration and can therefore be used repeatedly
@@ -27,7 +27,7 @@ struct I1 : B1 {
 //   shall name a direct base class of the class being defined.
 
 struct D1 : I1 {
-  using B1::B1; // expected-error {{'B1' is not a direct base of 'D1', can not inherit constructors}}
+  using B1::B1; // expected-error {{'B1' is not a direct base of 'D1', cannot inherit constructors}}
 };
 
 template<typename T> struct A {};
@@ -47,7 +47,7 @@ C<char> cc; // expected-note {{here}}
 
 template<typename T> struct D : A<T> {};
 template<typename T> struct E : D<T> {
-  using A<bool>::A; // expected-error {{'A<bool>' is not a direct base of 'E<bool>', can not inherit}}
+  using A<bool>::A; // expected-error {{'A<bool>' is not a direct base of 'E<bool>', cannot inherit}}
 };
 E<bool> eb; // expected-note {{here}}
 

clang/test/CXX/temp/temp.decls/temp.class.spec/p8-1y.cpp

@@ -21,10 +21,10 @@ template<template<typename> class...X> int v4<X...>;
 
 template<typename Outer> struct X {
   template<typename Inner> static int y;
-  template<typename Inner> static int y<Outer>; // expected-warning {{can not be deduced}} expected-note {{'Inner'}}
+  template<typename Inner> static int y<Outer>; // expected-warning {{cannot be deduced}} expected-note {{'Inner'}}
   template<typename Inner> static int y<Inner>; // expected-error {{does not specialize}}
 };
-template<typename Outer> template<typename Inner> int X<Outer>::y<Outer>; // expected-warning {{can not be deduced}} expected-note {{'Inner'}}
+template<typename Outer> template<typename Inner> int X<Outer>::y<Outer>; // expected-warning {{cannot be deduced}} expected-note {{'Inner'}}
 template<typename Outer> template<typename Inner> int X<Outer>::y<Inner>; // expected-error {{does not specialize}}
 
 // FIXME: Merging this with the above class causes an assertion failure when

clang/test/CXX/temp/temp.decls/temp.mem/p3.cpp

@@ -1,6 +1,6 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s
 
 template <class T> struct AA { 
-  template <class C> virtual void g(C); // expected-error{{'virtual' can not be specified on member function templates}}
+  template <class C> virtual void g(C); // expected-error{{'virtual' cannot be specified on member function templates}}
   virtual void f();
 };

clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p9-0x.cpp

@@ -32,7 +32,7 @@ namespace PackExpansionNotAtEnd {
 
   template<typename ... Types, // expected-note{{non-deducible template parameter 'Types'}}
            typename Tail> // expected-note{{non-deducible template parameter 'Tail'}}
-  struct UselessPartialSpec<Types..., Tail>; // expected-warning{{class template partial specialization contains template parameters that can not be deduced; this partial specialization will never be used}}
+  struct UselessPartialSpec<Types..., Tail>; // expected-warning{{class template partial specialization contains template parameters that cannot be deduced; this partial specialization will never be used}}
 }
 
 namespace DeduceNonTypeTemplateArgsInArray {

clang/test/Parser/builtin_classify_type.c

@@ -9,7 +9,7 @@ int main() {
   struct foo s;
 
   static int ary[__builtin_classify_type(a)];
-  static int ary2[(__builtin_classify_type)(a)]; // expected-error{{variable length array declaration can not have 'static' storage duration}}
+  static int ary2[(__builtin_classify_type)(a)]; // expected-error{{variable length array declaration cannot have 'static' storage duration}}
   static int ary3[(*__builtin_classify_type)(a)]; // expected-error{{builtin functions must be directly called}}
 
   int result;

clang/test/Parser/cxx-decl.cpp

@@ -181,7 +181,7 @@ void test (DIE die, DIE *Die, DIE INT, DIE *FLOAT) {
 }
 
 namespace PR15017 {
-  template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' can not be defined in a type specifier}}
+  template<typename T = struct X { int i; }> struct S {}; // expected-error {{'PR15017::X' cannot be defined in a type specifier}}
 }
 
 // Ensure we produce at least some diagnostic for attributes in C++98.

clang/test/Parser/cxx-using-declaration.cpp

@@ -33,7 +33,7 @@ namespace E {
     template <typename TYPE> int funcE(TYPE arg) { return(arg); }
 }
 
-using E::funcE<int>; // expected-error{{using declaration can not refer to a template specialization}}
+using E::funcE<int>; // expected-error{{using declaration cannot refer to a template specialization}}
 
 namespace F {
     struct X;

clang/test/Parser/cxx11-type-specifier.cpp

@@ -15,8 +15,8 @@ void f() {
 
   // These parse as type definitions, not as type references with braced
   // initializers. Sad but true...
-  (void) new struct S {}; // expected-error{{'S' can not be defined in a type specifier}}
-  (void) new enum E { e }; // expected-error{{'E' can not be defined in a type specifier}}
+  (void) new struct S {}; // expected-error{{'S' cannot be defined in a type specifier}}
+  (void) new enum E { e }; // expected-error{{'E' cannot be defined in a type specifier}}
 }
 
 // And for trailing-type-specifier-seq

clang/test/Parser/namespace-alias-attr.cpp

@@ -4,5 +4,5 @@ namespace A
 {
 }
 
-namespace B __attribute__ (( static )) = A; // expected-error{{attributes can not be specified on namespace alias}}
+namespace B __attribute__ (( static )) = A; // expected-error{{attributes cannot be specified on namespace alias}}
 

clang/test/Parser/objc-error-qualified-implementation.m

@@ -6,24 +6,24 @@
 
 @interface I @end
 
-@implementation I<P> @end // expected-error {{@implementation declaration can not be protocol qualified}}
+@implementation I<P> @end // expected-error {{@implementation declaration cannot be protocol qualified}}
 
 @interface J < P,P >
 @end
 
 
-@implementation J < P,P > // expected-error {{@implementation declaration can not be protocol qualified}}
+@implementation J < P,P > // expected-error {{@implementation declaration cannot be protocol qualified}}
 @end
 
 @interface K @end
 
-@implementation K <P // expected-error {{@implementation declaration can not be protocol qualified}}
+@implementation K <P // expected-error {{@implementation declaration cannot be protocol qualified}}
 @end // expected-error {{expected '>'}}
 
 // rdar://13920026
-@implementation I (Cat) <P>  // expected-error {{@implementation declaration can not be protocol qualified}}
+@implementation I (Cat) <P>  // expected-error {{@implementation declaration cannot be protocol qualified}}
 - (void) Meth {}
 @end
 
-@implementation I (Cat1) <P // expected-error {{@implementation declaration can not be protocol qualified}}
+@implementation I (Cat1) <P // expected-error {{@implementation declaration cannot be protocol qualified}}
 @end // expected-error {{expected '>'}}

clang/test/Sema/vla.c

@@ -19,7 +19,7 @@ int x = sizeof(struct{char qq[x];}); // expected-error {{fields must have a cons
 // PR2352
 void f2(unsigned int m)
 {
-  extern int e1[2][m]; // expected-error {{variable length array declaration can not have 'extern' linkage}}
+  extern int e1[2][m]; // expected-error {{variable length array declaration cannot have 'extern' linkage}}
 
   e1[0][0] = 0;
   
@@ -34,10 +34,10 @@ int (*e)[i]; // expected-error {{variably modified type declaration not allowed
 
 void f3()
 {
-  static int a[i]; // expected-error {{variable length array declaration can not have 'static' storage duration}}
-  extern int b[i]; // expected-error {{variable length array declaration can not have 'extern' linkage}}
+  static int a[i]; // expected-error {{variable length array declaration cannot have 'static' storage duration}}
+  extern int b[i]; // expected-error {{variable length array declaration cannot have 'extern' linkage}}
 
-  extern int (*c1)[i]; // expected-error {{variably modified type declaration can not have 'extern' linkage}}
+  extern int (*c1)[i]; // expected-error {{variably modified type declaration cannot have 'extern' linkage}}
   static int (*d)[i];
 }
 

clang/test/SemaCXX/alias-template.cpp

@@ -102,10 +102,10 @@ class CtorDtorName {
 };
 
 namespace TagName {
-  template<typename Z> using S = struct { int n; }; // expected-error {{can not be defined}}
-  template<typename Z> using T = class { int n; }; // expected-error {{can not be defined}}
-  template<typename Z> using U = enum { a, b, c }; // expected-error {{can not be defined}}
-  template<typename Z> using V = struct V { int n; }; // expected-error {{'TagName::V' can not be defined in a type alias template}}
+  template<typename Z> using S = struct { int n; }; // expected-error {{cannot be defined}}
+  template<typename Z> using T = class { int n; }; // expected-error {{cannot be defined}}
+  template<typename Z> using U = enum { a, b, c }; // expected-error {{cannot be defined}}
+  template<typename Z> using V = struct V { int n; }; // expected-error {{'TagName::V' cannot be defined in a type alias template}}
 }
 
 namespace StdExample {

clang/test/SemaCXX/conversion-function.cpp

@@ -408,8 +408,8 @@ namespace PR12712 {
 
 namespace PR18234 {
   struct A {
-    operator enum E { e } (); // expected-error {{'PR18234::A::E' can not be defined in a type specifier}}
-    operator struct S { int n; } (); // expected-error {{'PR18234::A::S' can not be defined in a type specifier}}
+    operator enum E { e } (); // expected-error {{'PR18234::A::E' cannot be defined in a type specifier}}
+    operator struct S { int n; } (); // expected-error {{'PR18234::A::S' cannot be defined in a type specifier}}
   } a;
   A::S s = a;
   A::E e = a; // expected-note {{here}}

clang/test/SemaCXX/type-definition-in-specifier.cpp

@@ -13,11 +13,11 @@ struct S0 { int x; };
 void f0() {
   typedef struct S1 { int x; } S1_typedef;
 
-  (void)((struct S2 { int x; }*)0); // expected-error{{can not be defined}}
+  (void)((struct S2 { int x; }*)0); // expected-error{{cannot be defined}}
 
   struct S3 { int x; } s3;
 
-  (void)static_cast<struct S4 { int x; } *>(0); // expected-error{{can not be defined}}
+  (void)static_cast<struct S4 { int x; } *>(0); // expected-error{{cannot be defined}}
 }
 
 struct S5 { int x; } f1() { return S5(); } // expected-error{{result type}}

clang/test/SemaObjCXX/exceptions-fragile.mm

@@ -6,7 +6,7 @@ void opaque();
 namespace test0 {
   void test() {
     try {
-    } catch (NSException *e) { // expected-warning {{can not catch an exception thrown with @throw in C++ in the non-unified exception model}}
+    } catch (NSException *e) { // expected-warning {{cannot catch an exception thrown with @throw in C++ in the non-unified exception model}}
     }
   }
 }