[PATCH] Replace "can not" with "cannot" in diagnostics messages
Ismail Pazarbasi
ismail.pazarbasi at gmail.com
Fri Mar 7 14:31:45 PST 2014
As subject says, "can not" has been replaced with "cannot" in
diagnostics and tests.
-------------- next part --------------
Index: include/clang/Basic/DiagnosticParseKinds.td
===================================================================
--- include/clang/Basic/DiagnosticParseKinds.td (revision 203166)
+++ include/clang/Basic/DiagnosticParseKinds.td (working copy)
@@ -190,13 +190,13 @@
def err_expected_semi_after_method_proto : Error<
"expected ';' after method prototype">;
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">;
def err_nested_namespaces_with_double_colon : Error<
"nested namespace definition must define each namespace separately">;
def err_expected_semi_after_attribute_list : Error<
@@ -409,13 +409,13 @@
def err_missing_catch_finally : Error<
"@try statement without a @catch and @finally clause">;
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<
"property synthesize requires specification of an ivar">;
def err_synthesized_property_name : Error<
"expected a property name in @synthesize">;
Index: include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- include/clang/Basic/DiagnosticSemaKinds.td (revision 203166)
+++ include/clang/Basic/DiagnosticSemaKinds.td (working copy)
@@ -103,15 +103,15 @@
"variable length array cannot be formed during template argument deduction">;
def err_array_star_in_function_definition : Error<
"variable length array must be bound in function definition">;
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>;
// C99 variably modified types
def err_variably_modified_template_arg : Error<
"variably modified type %0 cannot be used as a template argument">;
@@ -270,15 +270,15 @@
"using declaration in class refers into '%0', which is not a class">;
def err_using_decl_nested_name_specifier_is_current_class : Error<
"using declaration refers to its own class">;
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">;
def note_using_decl_constructor_conflict_previous_ctor : Note<
"previous constructor">;
def note_using_decl_constructor_conflict_previous_using : Note<
@@ -286,24 +286,24 @@
def warn_using_decl_constructor_ellipsis : Warning<
"inheriting constructor does not inherit ellipsis">,
InGroup<DiagGroup<"inherited-variadic-ctor">>;
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">;
def err_using_decl_conflict : Error<
"target of using declaration conflicts with declaration already in scope">;
def err_using_decl_conflict_reverse : Error<
@@ -858,13 +858,13 @@
"property %0 attempting to use instance variable %1 declared in super class %2">;
def error_weak_property : Error<
"existing instance variable %1 for __weak property %0 must be __weak">;
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">;
def warn_objc_missing_super_call : Warning<
"method possibly missing a [super %0] call">,
InGroup<ObjCMissingSuperCalls>;
@@ -983,19 +983,19 @@
def err_multiple_final_overriders : Error<
"virtual function %q0 has more than one final overrider in %1">;
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">;
def err_deleted_decl_not_first : Error<
"deleted definition must be first declaration">;
@@ -1159,13 +1159,13 @@
"'mutable' can only be applied to member variables">;
def err_virtual_non_function : Error<
"'virtual' can only appear on non-static member functions">;
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<
"'explicit' can only appear on non-static member functions">;
def err_explicit_out_of_class : Error<
"'explicit' can only be specified inside the class definition">;
@@ -3252,13 +3252,13 @@
def err_partial_spec_args_match_primary_template : Error<
"%select{class|variable}0 template partial specialization does not "
"specialize any template argument; to %select{declare|define}1 the "
"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">;
def err_partial_spec_ordering_ambiguous : Error<
"ambiguous partial specializations of %0">;
def note_partial_spec_match : Note<"partial specialization matches %0">;
@@ -3782,13 +3782,13 @@
def warn_illegal_constant_array_size : Extension<
"size of static array must be an integer constant expression">;
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">;
def err_vm_func_decl : Error<
"function declaration cannot have variably modified type">;
def err_array_too_large : Error<
@@ -4907,13 +4907,13 @@
"@catch parameter cannot have storage specifier '%0'">;
def warn_register_objc_catch_parm : Warning<
"'register' storage specifier on @catch parameter will be ignored">;
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">;
def err_incomplete_type_objc_at_encode : Error<
"'@encode' of incomplete type %0">;
Index: test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp
===================================================================
--- test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp (revision 203166)
+++ test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p5-cxx0x.cpp (working copy)
@@ -4,9 +4,9 @@
struct A {
template<class T> void f(T);
template<class T> struct X { };
};
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}}
};
Index: test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp
===================================================================
--- test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp (revision 203166)
+++ test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p6-cxx0x.cpp (working copy)
@@ -2,7 +2,7 @@
// C++0x N2914.
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}}
Index: test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp
===================================================================
--- test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp (revision 203166)
+++ test/CXX/dcl.dcl/basic.namespace/namespace.udecl/p8-cxx0x.cpp (working copy)
@@ -3,13 +3,13 @@
struct X {
int i;
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}}
}
Index: test/CXX/dcl.dcl/dcl.spec/dcl.type/p3-0x.cpp
===================================================================
--- test/CXX/dcl.dcl/dcl.spec/dcl.type/p3-0x.cpp (revision 203166)
+++ test/CXX/dcl.dcl/dcl.spec/dcl.type/p3-0x.cpp (working copy)
@@ -1,43 +1,43 @@
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s -fcxx-exceptions
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 {};
void f() {
int arr[3] = {1,2,3};
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}}
Index: test/CXX/dcl.decl/dcl.meaning/dcl.fct/p8.cpp
===================================================================
--- test/CXX/dcl.decl/dcl.meaning/dcl.fct/p8.cpp (revision 203166)
+++ test/CXX/dcl.decl/dcl.meaning/dcl.fct/p8.cpp (working copy)
@@ -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}}
Index: test/CXX/drs/dr1xx.cpp
===================================================================
--- test/CXX/drs/dr1xx.cpp (revision 203166)
+++ test/CXX/drs/dr1xx.cpp (working copy)
@@ -63,13 +63,13 @@
template<> struct A<int>::B { int X; };
}
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'}}
};
}
namespace dr111 { // dr111: dup 535
struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); };
@@ -719,15 +719,15 @@
template<typename> struct C;
template<typename> void f();
template<typename> static int n; // expected-error 0-1{{extension}}
};
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}}
};
}
namespace { // dr171: yes
int dr171a;
}
Index: test/CXX/special/class.inhctor/elsewhere.cpp
===================================================================
--- test/CXX/special/class.inhctor/elsewhere.cpp (revision 203166)
+++ test/CXX/special/class.inhctor/elsewhere.cpp (working copy)
@@ -6,13 +6,13 @@
// A using-declaration for a class member shall be a member-declaration.
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
// where (and only where) multiple declarations are allowed.
struct I1 : B1 {
@@ -24,13 +24,13 @@
// In a using declaration used as a member-declaration, the nested-name-
// specifier shall name a base class of the class being defined.
// If such a using-declaration names a constructor, the nested-name-specifier
// 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 {};
template<typename T> struct B : A<bool>, A<char> {
using A<T>::A; // expected-error {{'A<double>::', which is not a base class of 'B<double>'}}
@@ -44,13 +44,13 @@
};
C<bool> cb;
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}}
template<typename T> struct F : D<bool> {
using A<T>::A; // expected-error {{'A<bool>' is not a direct base of 'F<bool>'}}
};
Index: test/CXX/temp/temp.decls/temp.class.spec/p8-1y.cpp
===================================================================
--- test/CXX/temp/temp.decls/temp.class.spec/p8-1y.cpp (revision 203166)
+++ test/CXX/temp/temp.decls/temp.class.spec/p8-1y.cpp (working copy)
@@ -18,16 +18,16 @@
template<template<typename> class...X> int v4;
template<template<typename> class...X> int v4<X...>;
// expected-error at -1{{variable template partial specialization does not specialize any template argument; to define the primary template, remove the template argument list}}
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
// instantiating one of the bogus partial specializations.
template<typename Outer> struct Y {
template<typename Inner> static int y;
Index: test/CXX/temp/temp.decls/temp.mem/p3.cpp
===================================================================
--- test/CXX/temp/temp.decls/temp.mem/p3.cpp (revision 203166)
+++ test/CXX/temp/temp.decls/temp.mem/p3.cpp (working copy)
@@ -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();
};
Index: test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p9-0x.cpp
===================================================================
--- test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p9-0x.cpp (revision 203166)
+++ test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p9-0x.cpp (working copy)
@@ -29,13 +29,13 @@
>::value? 1 : -1];
template<typename ... Types> struct UselessPartialSpec;
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 {
template<typename ...ArrayTypes>
struct split_arrays;
Index: test/Parser/builtin_classify_type.c
===================================================================
--- test/Parser/builtin_classify_type.c (revision 203166)
+++ test/Parser/builtin_classify_type.c (working copy)
@@ -6,13 +6,13 @@
int a;
float b;
double d;
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;
result = __builtin_classify_type(a);
result = __builtin_classify_type(b);
Index: test/Parser/cxx-decl.cpp
===================================================================
--- test/Parser/cxx-decl.cpp (revision 203166)
+++ test/Parser/cxx-decl.cpp (working copy)
@@ -178,13 +178,13 @@
float->foo(); // expected-error {{cannot use arrow operator on a type}}
FLOAT->foo();
}
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.
[[]] struct S; // expected-error 2{{}}
namespace test7 {
Index: test/Parser/cxx-using-declaration.cpp
===================================================================
--- test/Parser/cxx-using-declaration.cpp (revision 203166)
+++ test/Parser/cxx-using-declaration.cpp (working copy)
@@ -30,13 +30,13 @@
void D::g(int) { g('c'); } // recursively calls D::g(int)
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;
}
using F::X;
Index: test/Parser/cxx11-type-specifier.cpp
===================================================================
--- test/Parser/cxx11-type-specifier.cpp (revision 203166)
+++ test/Parser/cxx11-type-specifier.cpp (working copy)
@@ -12,13 +12,13 @@
(void) new constexpr int; // expected-error{{type name does not allow constexpr}}
} catch (constexpr int) { // expected-error{{type name does not allow constexpr}}
}
// 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
auto f() -> unknown; // expected-error{{unknown type name 'unknown'}}
Index: test/Parser/namespace-alias-attr.cpp
===================================================================
--- test/Parser/namespace-alias-attr.cpp (revision 203166)
+++ test/Parser/namespace-alias-attr.cpp (working copy)
@@ -1,8 +1,8 @@
// RUN: %clang_cc1 -verify %s
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}}
Index: test/Parser/objc-error-qualified-implementation.m
===================================================================
--- test/Parser/objc-error-qualified-implementation.m (revision 203166)
+++ test/Parser/objc-error-qualified-implementation.m (working copy)
@@ -3,27 +3,27 @@
@protocol P
@end
@interface I @end
- at implementation I<P> @end // expected-error {{@implementation declaration can not be protocol qualified}}
+ at implementation I<P> @end // expected-error {{@implementation declaration cannot be protocol qualified}}
@interface J < P,P >
@end
- at implementation J < P,P > // expected-error {{@implementation declaration can not be protocol qualified}}
+ at implementation J < P,P > // expected-error {{@implementation declaration cannot be protocol qualified}}
@end
@interface K @end
- at implementation K <P // expected-error {{@implementation declaration can not be protocol qualified}}
+ at implementation K <P // expected-error {{@implementation declaration cannot be protocol qualified}}
@end // expected-error {{expected '>'}}
// rdar://13920026
- at implementation I (Cat) <P> // expected-error {{@implementation declaration can not be protocol qualified}}
+ at implementation I (Cat) <P> // expected-error {{@implementation declaration cannot be protocol qualified}}
- (void) Meth {}
@end
- at implementation I (Cat1) <P // expected-error {{@implementation declaration can not be protocol qualified}}
+ at implementation I (Cat1) <P // expected-error {{@implementation declaration cannot be protocol qualified}}
@end // expected-error {{expected '>'}}
Index: test/Sema/vla.c
===================================================================
--- test/Sema/vla.c (revision 203166)
+++ test/Sema/vla.c (working copy)
@@ -16,13 +16,13 @@
// PR3048
int x = sizeof(struct{char qq[x];}); // expected-error {{fields must have a constant size}}
// 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;
}
// PR2361
@@ -31,16 +31,16 @@
int d[i]; // expected-error {{variable length array declaration not allowed at file scope}}
int (*e)[i]; // expected-error {{variably modified type declaration not allowed at file scope}}
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];
}
// PR3663
static const unsigned array[((2 * (int)((((4) / 2) + 1.0/3.0) * (4) - 1e-8)) + 1)]; // expected-warning {{variable length array folded to constant array as an extension}}
Index: test/SemaCXX/alias-template.cpp
===================================================================
--- test/SemaCXX/alias-template.cpp (revision 203166)
+++ test/SemaCXX/alias-template.cpp (working copy)
@@ -99,16 +99,16 @@
template<typename T> using X = CtorDtorName;
X<int>(); // expected-error {{expected member name}}
~X<int>(); // expected-error {{destructor cannot be declared using a type alias}}
};
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 {
template<typename T, typename U> struct pair;
template<typename T> using handler_t = void (*)(T);
Index: test/SemaCXX/conversion-function.cpp
===================================================================
--- test/SemaCXX/conversion-function.cpp (revision 203166)
+++ test/SemaCXX/conversion-function.cpp (working copy)
@@ -405,14 +405,14 @@
A f(const C c) { return c; }
}
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}}
bool k1 = e == A::e; // expected-error {{no member named 'e'}}
bool k2 = e.n == 0;
}
Index: test/SemaCXX/type-definition-in-specifier.cpp
===================================================================
--- test/SemaCXX/type-definition-in-specifier.cpp (revision 203166)
+++ test/SemaCXX/type-definition-in-specifier.cpp (working copy)
@@ -10,16 +10,16 @@
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}}
void f2(struct S6 { int x; } p); // expected-error{{parameter type}}
Index: test/SemaObjCXX/exceptions-fragile.mm
===================================================================
--- test/SemaObjCXX/exceptions-fragile.mm (revision 203166)
+++ test/SemaObjCXX/exceptions-fragile.mm (working copy)
@@ -3,10 +3,10 @@
@interface NSException @end
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}}
}
}
}
More information about the cfe-commits
mailing list