Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-02-19 09:26:59 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[Sema] Be consistent about diagnostic wording: always use "cannot".

Browse Source 
Discussed with Richard Smith.

llvm-svn: 245162
This commit is contained in:
Davide Italiano 2015-08-15 15:23:14 +00:00
parent 8b2a031cff
commit 32cbff7809
13 changed files with 105 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
clang/include/clang/Basic/DiagnosticSemaKinds.td
View File

@ -2083,9 +2083,9 @@ def err_attribute_invalid_size : Error<
def err_attribute_zero_size : Error<"zero vector size">; def err_attribute_zero_size : Error<"zero vector size">;
def err_attribute_size_too_large : Error<"vector size too large">; def err_attribute_size_too_large : Error<"vector size too large">;
def err_typecheck_vector_not_convertable : Error< def err_typecheck_vector_not_convertable : Error<
"can't convert between vector values of different size (%0 and %1)">; "cannot convert between vector values of different size (%0 and %1)">;
def err_typecheck_vector_not_convertable_non_scalar : Error< def err_typecheck_vector_not_convertable_non_scalar : Error<
"can't convert between vector and non-scalar values (%0 and %1)">; "cannot convert between vector and non-scalar values (%0 and %1)">;
def err_typecheck_vector_lengths_not_equal : Error< def err_typecheck_vector_lengths_not_equal : Error<
"vector operands do not have the same number of elements (%0 and %1)">; "vector operands do not have the same number of elements (%0 and %1)">;
def err_ext_vector_component_exceeds_length : Error< def err_ext_vector_component_exceeds_length : Error<
@ -2888,7 +2888,7 @@ def err_param_default_argument_on_parameter_pack : Error<
"parameter pack cannot have a default argument">; "parameter pack cannot have a default argument">;
def err_uninitialized_member_for_assign : Error< def err_uninitialized_member_for_assign : Error<
"cannot define the implicit copy assignment operator for %0, because " "cannot define the implicit copy assignment operator for %0, because "
"non-static %select{reference|const}1 member %2 can't use copy " "non-static %select{reference|const}1 member %2 cannot use copy "
"assignment operator">; "assignment operator">;
def err_uninitialized_member_in_ctor : Error< def err_uninitialized_member_in_ctor : Error<
"%select{|implicit default |inheriting }0constructor for %1 must explicitly " "%select{|implicit default |inheriting }0constructor for %1 must explicitly "
@ -2972,7 +2972,7 @@ def note_ovl_candidate_instantiation_depth : Note<
"candidate template ignored: substitution exceeded maximum template " "candidate template ignored: substitution exceeded maximum template "
"instantiation depth">; "instantiation depth">;
def note_ovl_candidate_underqualified : Note< def note_ovl_candidate_underqualified : Note<
"candidate template ignored: can't deduce a type for %0 that would " "candidate template ignored: cannot deduce a type for %0 that would "
"make %2 equal %1">; "make %2 equal %1">;
def note_ovl_candidate_substitution_failure : Note< def note_ovl_candidate_substitution_failure : Note<
"candidate template ignored: substitution failure%0%1">; "candidate template ignored: substitution failure%0%1">;
@ -3262,7 +3262,7 @@ def err_addr_ovl_ambiguous : Error<
def err_addr_ovl_not_func_ptrref : Error< def err_addr_ovl_not_func_ptrref : Error<
"address of overloaded function %0 cannot be converted to type %1">; "address of overloaded function %0 cannot be converted to type %1">;
def err_addr_ovl_no_qualifier : Error< def err_addr_ovl_no_qualifier : Error<
"can't form member pointer of type %0 without '&' and class name">; "cannot form member pointer of type %0 without '&' and class name">;
// C++11 Literal Operators // C++11 Literal Operators
def err_ovl_no_viable_literal_operator : Error< def err_ovl_no_viable_literal_operator : Error<
@ -4556,7 +4556,7 @@ def err_typecheck_arc_assign_self : Error<
def err_typecheck_arc_assign_self_class_method : Error< def err_typecheck_arc_assign_self_class_method : Error<
"cannot assign to 'self' in a class method">; "cannot assign to 'self' in a class method">;
def err_typecheck_arr_assign_enumeration : Error< def err_typecheck_arr_assign_enumeration : Error<
"fast enumeration variables can't be modified in ARC by default; " "fast enumeration variables cannot be modified in ARC by default; "
"declare the variable __strong to allow this">; "declare the variable __strong to allow this">;
def warn_arc_retained_assign : Warning< def warn_arc_retained_assign : Warning<
"assigning retained object to %select{weak|unsafe_unretained}0 " "assigning retained object to %select{weak|unsafe_unretained}0 "
@ -5370,7 +5370,7 @@ def warn_objc_pointer_cxx_catch_fragile : Warning<
"cannot 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>; "exception model">, InGroup<ObjCNonUnifiedException>;
def err_objc_object_catch : Error< def err_objc_object_catch : Error<
"can't catch an Objective-C object by value">; "cannot catch an Objective-C object by value">;
def err_incomplete_type_objc_at_encode : Error< def err_incomplete_type_objc_at_encode : Error<
"'@encode' of incomplete type %0">; "'@encode' of incomplete type %0">;
def warn_objc_circular_container : Warning< def warn_objc_circular_container : Warning<

2
clang/test/CXX/expr/expr.unary/expr.unary.op/p4.cpp
View File

@ -7,7 +7,7 @@ namespace test0 {
template<typename T> void g(T); template<typename T> void g(T);
void test() { void test() {
foo(&g<int>); // expected-error-re {{can't form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}} foo(&g<int>); // expected-error-re {{cannot form member pointer of type 'void (test0::A::*)(int){{( __attribute__\(\(thiscall\)\))?}}' without '&' and class name}}
} }
}; };
} }

6
clang/test/CXX/over/over.over/p2-resolve-single-template-id.cpp
View File

@ -180,12 +180,12 @@ namespace member_pointers {
{ bool b = &s.g<int>; } { bool b = &s.g<int>; }
{ bool b = S::h<42>; } { bool b = S::h<42>; }
{ bool b = S::h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} { bool b = S::h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}}
{ bool b = &S::h<42>; } { bool b = &S::h<42>; }
{ bool b = &S::h<int>; } { bool b = &S::h<int>; }
{ bool b = s.h<42>; } { bool b = s.h<42>; }
{ bool b = s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} { bool b = s.h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}}
{ bool b = &s.h<42>; } { bool b = &s.h<42>; }
{ bool b = &s.h<int>; } // expected-error {{can't form member pointer of type 'bool' without '&' and class name}} { bool b = &s.h<int>; } // expected-error {{cannot form member pointer of type 'bool' without '&' and class name}}
} }
} }

12
clang/test/Sema/ext_vector_casts.c
View File

@ -20,8 +20,8 @@ static void test() {
int *ptr; int *ptr;
int i; int i;
vec3 += vec2; // expected-error {{can't convert between vector values of different size}} vec3 += vec2; // expected-error {{cannot convert between vector values of different size}}
vec4 += vec3; // expected-error {{can't convert between vector values of different size}} vec4 += vec3; // expected-error {{cannot convert between vector values of different size}}
vec4 = 5.0f; vec4 = 5.0f;
vec4 = (float4)5.0f; vec4 = (float4)5.0f;
@ -44,11 +44,11 @@ static void test() {
vec4 /= 5.2f; vec4 /= 5.2f;
vec4 %= 4; // expected-error {{invalid operands to binary expression ('float4' (vector of 4 'float' values) and 'int')}} vec4 %= 4; // expected-error {{invalid operands to binary expression ('float4' (vector of 4 'float' values) and 'int')}}
ivec4 %= 4; ivec4 %= 4;
ivec4 += vec4; // expected-error {{can't convert between vector values of different size ('int4' (vector of 4 'int' values) and 'float4' (vector of 4 'float' values))}} ivec4 += vec4; // expected-error {{cannot convert between vector values of different size ('int4' (vector of 4 'int' values) and 'float4' (vector of 4 'float' values))}}
ivec4 += (int4)vec4; ivec4 += (int4)vec4;
ivec4 -= ivec4; ivec4 -= ivec4;
ivec4 |= ivec4; ivec4 |= ivec4;
ivec4 += ptr; // expected-error {{can't convert between vector and non-scalar values ('int4' (vector of 4 'int' values) and 'int *')}} ivec4 += ptr; // expected-error {{cannot convert between vector and non-scalar values ('int4' (vector of 4 'int' values) and 'int *')}}
} }
typedef __attribute__(( ext_vector_type(2) )) float2 vecfloat2; // expected-error{{invalid vector element type 'float2' (vector of 2 'float' values)}} typedef __attribute__(( ext_vector_type(2) )) float2 vecfloat2; // expected-error{{invalid vector element type 'float2' (vector of 2 'float' values)}}
@ -102,11 +102,11 @@ static void splats(int i, long l, __uint128_t t, float f, double d) {
vs = 65536 + vs; // expected-warning {{implicit conversion from 'int' to 'short8' (vector of 8 'short' values) changes value from 65536 to 0}} vs = 65536 + vs; // expected-warning {{implicit conversion from 'int' to 'short8' (vector of 8 'short' values) changes value from 65536 to 0}}
vs = vs + i; // expected-warning {{implicit conversion loses integer precision}} vs = vs + i; // expected-warning {{implicit conversion loses integer precision}}
vs = vs + 1; vs = vs + 1;
vs = vs + 1.f; // expected-error {{can't convert between vector values of different size}} vs = vs + 1.f; // expected-error {{cannot convert between vector values of different size}}
vi = l + vi; // expected-warning {{implicit conversion loses integer precision}} vi = l + vi; // expected-warning {{implicit conversion loses integer precision}}
vi = 1 + vi; vi = 1 + vi;
vi = vi + 2.0; // expected-error {{can't convert between vector values of different size}} vi = vi + 2.0; // expected-error {{cannot convert between vector values of different size}}
vi = vi + 0xffffffff; // expected-warning {{implicit conversion changes signedness}} vi = vi + 0xffffffff; // expected-warning {{implicit conversion changes signedness}}
vl = l + vl; // expected-warning {{implicit conversion changes signedness}} vl = l + vl; // expected-warning {{implicit conversion changes signedness}}

148
clang/test/Sema/zvector.c
View File

@ -309,14 +309,14 @@ void foo(void)
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
sc = sc + sc2; sc = sc + sc2;
sc = sc + uc2; // expected-error {{can't convert}} sc = sc + uc2; // expected-error {{cannot convert}}
sc = uc + sc2; // expected-error {{can't convert}} sc = uc + sc2; // expected-error {{cannot convert}}
sc = sc + bc2; sc = sc + bc2;
sc = bc + sc2; sc = bc + sc2;
uc = uc + uc2; uc = uc + uc2;
uc = sc + uc2; // expected-error {{can't convert}} uc = sc + uc2; // expected-error {{cannot convert}}
uc = uc + sc2; // expected-error {{can't convert}} uc = uc + sc2; // expected-error {{cannot convert}}
uc = bc + uc2; uc = bc + uc2;
uc = uc + bc2; uc = uc + bc2;
@ -326,14 +326,14 @@ void foo(void)
bc = bc + sc2; // expected-error {{incompatible type}} bc = bc + sc2; // expected-error {{incompatible type}}
bc = sc + bc2; // expected-error {{incompatible type}} bc = sc + bc2; // expected-error {{incompatible type}}
sc = sc + sc_scalar; // expected-error {{can't convert}} sc = sc + sc_scalar; // expected-error {{cannot convert}}
sc = sc + uc_scalar; // expected-error {{can't convert}} sc = sc + uc_scalar; // expected-error {{cannot convert}}
sc = sc_scalar + sc; // expected-error {{can't convert}} sc = sc_scalar + sc; // expected-error {{cannot convert}}
sc = uc_scalar + sc; // expected-error {{can't convert}} sc = uc_scalar + sc; // expected-error {{cannot convert}}
uc = uc + sc_scalar; // expected-error {{can't convert}} uc = uc + sc_scalar; // expected-error {{cannot convert}}
uc = uc + uc_scalar; // expected-error {{can't convert}} uc = uc + uc_scalar; // expected-error {{cannot convert}}
uc = sc_scalar + uc; // expected-error {{can't convert}} uc = sc_scalar + uc; // expected-error {{cannot convert}}
uc = uc_scalar + uc; // expected-error {{can't convert}} uc = uc_scalar + uc; // expected-error {{cannot convert}}
ss = ss + ss2; ss = ss + ss2;
us = us + us2; us = us + us2;
@ -348,30 +348,30 @@ void foo(void)
bl = bl + bl2; // expected-error {{invalid operands}} bl = bl + bl2; // expected-error {{invalid operands}}
fd = fd + fd2; fd = fd + fd2;
fd = fd + ul2; // expected-error {{can't convert}} fd = fd + ul2; // expected-error {{cannot convert}}
fd = sl + fd2; // expected-error {{can't convert}} fd = sl + fd2; // expected-error {{cannot convert}}
sc += sc2; sc += sc2;
sc += uc2; // expected-error {{can't convert}} sc += uc2; // expected-error {{cannot convert}}
sc += bc2; sc += bc2;
uc += uc2; uc += uc2;
uc += sc2; // expected-error {{can't convert}} uc += sc2; // expected-error {{cannot convert}}
uc += bc2; uc += bc2;
bc += bc2; // expected-error {{invalid operands}} bc += bc2; // expected-error {{invalid operands}}
bc += sc2; // expected-error {{can't convert}} bc += sc2; // expected-error {{cannot convert}}
bc += uc2; // expected-error {{can't convert}} bc += uc2; // expected-error {{cannot convert}}
sc += ss2; // expected-error {{can't convert}} sc += ss2; // expected-error {{cannot convert}}
sc += si2; // expected-error {{can't convert}} sc += si2; // expected-error {{cannot convert}}
sc += sl2; // expected-error {{can't convert}} sc += sl2; // expected-error {{cannot convert}}
sc += fd2; // expected-error {{can't convert}} sc += fd2; // expected-error {{cannot convert}}
sc += sc_scalar; // expected-error {{can't convert}} sc += sc_scalar; // expected-error {{cannot convert}}
sc += uc_scalar; // expected-error {{can't convert}} sc += uc_scalar; // expected-error {{cannot convert}}
uc += sc_scalar; // expected-error {{can't convert}} uc += sc_scalar; // expected-error {{cannot convert}}
uc += uc_scalar; // expected-error {{can't convert}} uc += uc_scalar; // expected-error {{cannot convert}}
ss += ss2; ss += ss2;
us += us2; us += us2;
@ -395,7 +395,7 @@ void foo(void)
uc = uc - uc2; uc = uc - uc2;
bc = bc - bc2; // expected-error {{invalid operands}} bc = bc - bc2; // expected-error {{invalid operands}}
sc = uc - sc2; // expected-error {{can't convert}} sc = uc - sc2; // expected-error {{cannot convert}}
sc = sc - bc2; sc = sc - bc2;
uc = bc - uc2; uc = bc - uc2;
@ -403,9 +403,9 @@ void foo(void)
uc -= uc2; uc -= uc2;
bc -= bc2; // expected-error {{invalid operands}} bc -= bc2; // expected-error {{invalid operands}}
sc -= uc2; // expected-error {{can't convert}} sc -= uc2; // expected-error {{cannot convert}}
uc -= bc2; uc -= bc2;
bc -= sc2; // expected-error {{can't convert}} bc -= sc2; // expected-error {{cannot convert}}
ss -= ss2; ss -= ss2;
us -= us2; us -= us2;
@ -430,17 +430,17 @@ void foo(void)
uc = uc * uc2; uc = uc * uc2;
bc = bc * bc2; // expected-error {{invalid operands}} bc = bc * bc2; // expected-error {{invalid operands}}
sc = uc * sc2; // expected-error {{can't convert}} sc = uc * sc2; // expected-error {{cannot convert}}
sc = sc * bc2; // expected-error {{can't convert}} sc = sc * bc2; // expected-error {{cannot convert}}
uc = bc * uc2; // expected-error {{can't convert}} uc = bc * uc2; // expected-error {{cannot convert}}
sc *= sc2; sc *= sc2;
uc *= uc2; uc *= uc2;
bc *= bc2; // expected-error {{invalid operands}} bc *= bc2; // expected-error {{invalid operands}}
sc *= uc2; // expected-error {{can't convert}} sc *= uc2; // expected-error {{cannot convert}}
uc *= bc2; // expected-error {{can't convert}} uc *= bc2; // expected-error {{cannot convert}}
bc *= sc2; // expected-error {{can't convert}} bc *= sc2; // expected-error {{cannot convert}}
ss *= ss2; ss *= ss2;
us *= us2; us *= us2;
@ -464,17 +464,17 @@ void foo(void)
uc = uc / uc2; uc = uc / uc2;
bc = bc / bc2; // expected-error {{invalid operands}} bc = bc / bc2; // expected-error {{invalid operands}}
sc = uc / sc2; // expected-error {{can't convert}} sc = uc / sc2; // expected-error {{cannot convert}}
sc = sc / bc2; // expected-error {{can't convert}} sc = sc / bc2; // expected-error {{cannot convert}}
uc = bc / uc2; // expected-error {{can't convert}} uc = bc / uc2; // expected-error {{cannot convert}}
sc /= sc2; sc /= sc2;
uc /= uc2; uc /= uc2;
bc /= bc2; // expected-error {{invalid operands}} bc /= bc2; // expected-error {{invalid operands}}
sc /= uc2; // expected-error {{can't convert}} sc /= uc2; // expected-error {{cannot convert}}
uc /= bc2; // expected-error {{can't convert}} uc /= bc2; // expected-error {{cannot convert}}
bc /= sc2; // expected-error {{can't convert}} bc /= sc2; // expected-error {{cannot convert}}
ss /= ss2; ss /= ss2;
us /= us2; us /= us2;
@ -498,17 +498,17 @@ void foo(void)
uc = uc % uc2; uc = uc % uc2;
bc = bc % bc2; // expected-error {{invalid operands}} bc = bc % bc2; // expected-error {{invalid operands}}
sc = uc % sc2; // expected-error {{can't convert}} sc = uc % sc2; // expected-error {{cannot convert}}
sc = sc % bc2; // expected-error {{can't convert}} sc = sc % bc2; // expected-error {{cannot convert}}
uc = bc % uc2; // expected-error {{can't convert}} uc = bc % uc2; // expected-error {{cannot convert}}
sc %= sc2; sc %= sc2;
uc %= uc2; uc %= uc2;
bc %= bc2; // expected-error {{invalid operands}} bc %= bc2; // expected-error {{invalid operands}}
sc %= uc2; // expected-error {{can't convert}} sc %= uc2; // expected-error {{cannot convert}}
uc %= bc2; // expected-error {{can't convert}} uc %= bc2; // expected-error {{cannot convert}}
bc %= sc2; // expected-error {{can't convert}} bc %= sc2; // expected-error {{cannot convert}}
ss %= ss2; ss %= ss2;
us %= us2; us %= us2;
@ -529,14 +529,14 @@ void foo(void)
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
sc = sc & sc2; sc = sc & sc2;
sc = sc & uc2; // expected-error {{can't convert}} sc = sc & uc2; // expected-error {{cannot convert}}
sc = uc & sc2; // expected-error {{can't convert}} sc = uc & sc2; // expected-error {{cannot convert}}
sc = sc & bc2; sc = sc & bc2;
sc = bc & sc2; sc = bc & sc2;
uc = uc & uc2; uc = uc & uc2;
uc = sc & uc2; // expected-error {{can't convert}} uc = sc & uc2; // expected-error {{cannot convert}}
uc = uc & sc2; // expected-error {{can't convert}} uc = uc & sc2; // expected-error {{cannot convert}}
uc = bc & uc2; uc = bc & uc2;
uc = uc & bc2; uc = uc & bc2;
@ -553,25 +553,25 @@ void foo(void)
fd = fd & ul2; // expected-error {{invalid operands}} fd = fd & ul2; // expected-error {{invalid operands}}
sc &= sc2; sc &= sc2;
sc &= uc2; // expected-error {{can't convert}} sc &= uc2; // expected-error {{cannot convert}}
sc &= bc2; sc &= bc2;
uc &= uc2; uc &= uc2;
uc &= sc2; // expected-error {{can't convert}} uc &= sc2; // expected-error {{cannot convert}}
uc &= bc2; uc &= bc2;
bc &= bc2; bc &= bc2;
bc &= sc2; // expected-error {{can't convert}} bc &= sc2; // expected-error {{cannot convert}}
bc &= uc2; // expected-error {{can't convert}} bc &= uc2; // expected-error {{cannot convert}}
sc &= ss2; // expected-error {{can't convert}} sc &= ss2; // expected-error {{cannot convert}}
sc &= si2; // expected-error {{can't convert}} sc &= si2; // expected-error {{cannot convert}}
sc &= sl2; // expected-error {{can't convert}} sc &= sl2; // expected-error {{cannot convert}}
sc &= fd2; // expected-error {{invalid operands}} sc &= fd2; // expected-error {{invalid operands}}
us &= bc2; // expected-error {{can't convert}} us &= bc2; // expected-error {{cannot convert}}
ui &= bc2; // expected-error {{can't convert}} ui &= bc2; // expected-error {{cannot convert}}
ul &= bc2; // expected-error {{can't convert}} ul &= bc2; // expected-error {{cannot convert}}
fd &= bc2; // expected-error {{invalid operands}} fd &= bc2; // expected-error {{invalid operands}}
ss &= ss2; ss &= ss2;
@ -591,11 +591,11 @@ void foo(void)
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
sc = sc | sc2; sc = sc | sc2;
sc = sc | uc2; // expected-error {{can't convert}} sc = sc | uc2; // expected-error {{cannot convert}}
sc = sc | bc2; sc = sc | bc2;
uc = uc | uc2; uc = uc | uc2;
uc = sc | uc2; // expected-error {{can't convert}} uc = sc | uc2; // expected-error {{cannot convert}}
uc = bc | uc2; uc = bc | uc2;
bc = bc | bc2; bc = bc | bc2;
@ -625,11 +625,11 @@ void foo(void)
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
sc = sc ^ sc2; sc = sc ^ sc2;
sc = sc ^ uc2; // expected-error {{can't convert}} sc = sc ^ uc2; // expected-error {{cannot convert}}
sc = sc ^ bc2; sc = sc ^ bc2;
uc = uc ^ uc2; uc = uc ^ uc2;
uc = sc ^ uc2; // expected-error {{can't convert}} uc = sc ^ uc2; // expected-error {{cannot convert}}
uc = bc ^ uc2; uc = bc ^ uc2;
bc = bc ^ bc2; bc = bc ^ bc2;
@ -862,10 +862,10 @@ void foo(void)
(void)(uc == uc2); (void)(uc == uc2);
(void)(bc == bc2); (void)(bc == bc2);
(void)(sc == uc); // expected-error {{can't convert}} (void)(sc == uc); // expected-error {{cannot convert}}
(void)(sc == bc); (void)(sc == bc);
(void)(uc == sc); // expected-error {{can't convert}} (void)(uc == sc); // expected-error {{cannot convert}}
(void)(uc == bc); (void)(uc == bc);
(void)(bc == sc); (void)(bc == sc);
@ -884,8 +884,8 @@ void foo(void)
(void)(bl == bl2); (void)(bl == bl2);
(void)(fd == fd2); (void)(fd == fd2);
(void)(fd == ul); // expected-error {{can't convert}} (void)(fd == ul); // expected-error {{cannot convert}}
(void)(ul == fd); // expected-error {{can't convert}} (void)(ul == fd); // expected-error {{cannot convert}}
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Test that == rules apply to != too. // Test that == rules apply to != too.
@ -895,7 +895,7 @@ void foo(void)
(void)(uc != uc2); (void)(uc != uc2);
(void)(bc != bc2); (void)(bc != bc2);
(void)(sc != uc); // expected-error {{can't convert}} (void)(sc != uc); // expected-error {{cannot convert}}
(void)(sc != bc); (void)(sc != bc);
(void)(ss != ss2); (void)(ss != ss2);
@ -919,7 +919,7 @@ void foo(void)
(void)(uc <= uc2); (void)(uc <= uc2);
(void)(bc <= bc2); (void)(bc <= bc2);
(void)(sc <= uc); // expected-error {{can't convert}} (void)(sc <= uc); // expected-error {{cannot convert}}
(void)(sc <= bc); (void)(sc <= bc);
(void)(ss <= ss2); (void)(ss <= ss2);
@ -943,7 +943,7 @@ void foo(void)
(void)(uc >= uc2); (void)(uc >= uc2);
(void)(bc >= bc2); (void)(bc >= bc2);
(void)(sc >= uc); // expected-error {{can't convert}} (void)(sc >= uc); // expected-error {{cannot convert}}
(void)(sc >= bc); (void)(sc >= bc);
(void)(ss >= ss2); (void)(ss >= ss2);
@ -967,7 +967,7 @@ void foo(void)
(void)(uc < uc2); (void)(uc < uc2);
(void)(bc < bc2); (void)(bc < bc2);
(void)(sc < uc); // expected-error {{can't convert}} (void)(sc < uc); // expected-error {{cannot convert}}
(void)(sc < bc); (void)(sc < bc);
(void)(ss < ss2); (void)(ss < ss2);
@ -991,7 +991,7 @@ void foo(void)
(void)(uc > uc2); (void)(uc > uc2);
(void)(bc > bc2); (void)(bc > bc2);
(void)(sc > uc); // expected-error {{can't convert}} (void)(sc > uc); // expected-error {{cannot convert}}
(void)(sc > bc); (void)(sc > bc);
(void)(ss > ss2); (void)(ss > ss2);

6
clang/test/SemaCXX/default-assignment-operator.cpp
View File

@ -1,12 +1,12 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify %s
class Base { // expected-error {{cannot define the implicit copy assignment operator for 'Base', because non-static reference member 'ref' can't use copy assignment operator}} \ class Base { // expected-error {{cannot define the implicit copy assignment operator for 'Base', because non-static reference member 'ref' cannot use copy assignment operator}} \
// expected-warning{{class 'Base' does not declare any constructor to initialize its non-modifiable members}} // expected-warning{{class 'Base' does not declare any constructor to initialize its non-modifiable members}}
int &ref; // expected-note {{declared here}} \ int &ref; // expected-note {{declared here}} \
// expected-note{{reference member 'ref' will never be initialized}} // expected-note{{reference member 'ref' will never be initialized}}
}; };
class X : Base { // // expected-error {{cannot define the implicit copy assignment operator for 'X', because non-static const member 'cint' can't use copy assignment operator}} \ class X : Base { // // expected-error {{cannot define the implicit copy assignment operator for 'X', because non-static const member 'cint' cannot use copy assignment operator}} \
// expected-note{{assignment operator for 'Base' first required here}} // expected-note{{assignment operator for 'Base' first required here}}
public: public:
X(); X();
@ -73,7 +73,7 @@ void i() {
// Test5 // Test5
class E1 { // expected-error{{cannot define the implicit copy assignment operator for 'E1', because non-static const member 'a' can't use copy assignment operator}} class E1 { // expected-error{{cannot define the implicit copy assignment operator for 'E1', because non-static const member 'a' cannot use copy assignment operator}}
public: public:
const int a; // expected-note{{declared here}} const int a; // expected-note{{declared here}}

4
clang/test/SemaCXX/vector-casts.cpp
View File

@ -59,10 +59,10 @@ void f() {
struct testvec { struct testvec {
__v2si v; __v2si v;
void madd(const testvec& rhs) { void madd(const testvec& rhs) {
v = v + rhs; // expected-error {{can't convert between vector and non-scalar values}} v = v + rhs; // expected-error {{cannot convert between vector and non-scalar values}}
} }
void madd2(testvec rhs) { void madd2(testvec rhs) {
v = v + rhs; // expected-error {{can't convert between vector and non-scalar values}} v = v + rhs; // expected-error {{cannot convert between vector and non-scalar values}}
} }
}; };

2
clang/test/SemaCXX/vector-no-lax.cpp
View File

@ -4,6 +4,6 @@ typedef int __attribute__((vector_size (16))) vSInt32;
vSInt32 foo (vUInt32 a) { vSInt32 foo (vUInt32 a) {
vSInt32 b = { 0, 0, 0, 0 }; vSInt32 b = { 0, 0, 0, 0 };
b += a; // expected-error{{can't convert between vector values}} b += a; // expected-error{{cannot convert between vector values}}
return b; return b;
} }

2
clang/test/SemaObjC/arc.m
View File

@ -290,7 +290,7 @@ void test11(id op, void *vp) {
void test12(id collection) { void test12(id collection) {
for (id x in collection) { for (id x in collection) {
x = 0; // expected-error {{fast enumeration variables can't be modified in ARC by default; declare the variable __strong to allow this}} x = 0; // expected-error {{fast enumeration variables cannot be modified in ARC by default; declare the variable __strong to allow this}}
} }
for (const id x in collection) { // expected-note {{variable 'x' declared const here}} for (const id x in collection) { // expected-note {{variable 'x' declared const here}}

2
clang/test/SemaObjCXX/exceptions.mm
View File

@ -5,7 +5,7 @@
namespace test0 { namespace test0 {
void test() { void test() {
try { try {
} catch (NSException e) { // expected-error {{can't catch an Objective-C object by value}} } catch (NSException e) { // expected-error {{cannot catch an Objective-C object by value}}
} }
} }
} }

6
clang/test/SemaOpenCL/cond.cl
View File

@ -84,12 +84,12 @@ uchar2 ntest03(int2 C, uchar X, uchar Y)
float2 ntest04(int2 C, int2 X, float2 Y) float2 ntest04(int2 C, int2 X, float2 Y)
{ {
return C ? X : Y; // expected-error {{can't convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float2' (vector of 2 'float' values))}} return C ? X : Y; // expected-error {{cannot convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float2' (vector of 2 'float' values))}}
} }
float2 ntest05(int2 C, int2 X, float Y) float2 ntest05(int2 C, int2 X, float Y)
{ {
return C ? X : Y; // expected-error {{can't convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float')}} return C ? X : Y; // expected-error {{cannot convert between vector values of different size ('int2' (vector of 2 'int' values) and 'float')}}
} }
char2 ntest06(int2 C, char2 X, char2 Y) char2 ntest06(int2 C, char2 X, char2 Y)
@ -115,7 +115,7 @@ int2 ntest09(int2 C, global int *X, global int *Y)
char3 ntest10(char C, char3 X, char2 Y) char3 ntest10(char C, char3 X, char2 Y)
{ {
return C ? X : Y; // expected-error {{can't convert between vector values of different size ('char3' (vector of 3 'char' values) and 'char2' (vector of 2 'char' values))}} return C ? X : Y; // expected-error {{cannot convert between vector values of different size ('char3' (vector of 3 'char' values) and 'char2' (vector of 2 'char' values))}}
} }
char3 ntest11(char2 C, char3 X, char Y) char3 ntest11(char2 C, char3 X, char Y)

2
clang/test/SemaTemplate/deduction.cpp
View File

@ -107,7 +107,7 @@ namespace PR7463 {
} }
namespace test0 { namespace test0 {
template <class T> void make(const T *(*fn)()); // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'char'}} template <class T> void make(const T *(*fn)()); // expected-note {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}}
char *char_maker(); char *char_maker();
void test() { void test() {
make(char_maker); // expected-error {{no matching function for call to 'make'}} make(char_maker); // expected-error {{no matching function for call to 'make'}}

4
clang/test/SemaTemplate/derived.cpp
View File

@ -4,8 +4,8 @@
template<typename T> class vector2 {}; template<typename T> class vector2 {};
template<typename T> class vector : vector2<T> {}; template<typename T> class vector : vector2<T> {};
template<typename T> void Foo2(vector2<const T*> V) {} // expected-note{{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'int'}} template<typename T> void Foo2(vector2<const T*> V) {} // expected-note{{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'int'}}
template<typename T> void Foo(vector<const T*> V) {} // expected-note {{candidate template ignored: can't deduce a type for 'T' that would make 'const T' equal 'int'}} template<typename T> void Foo(vector<const T*> V) {} // expected-note {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'int'}}
void test() { void test() {
Foo2(vector2<int*>()); // expected-error{{no matching function for call to 'Foo2'}} Foo2(vector2<int*>()); // expected-error{{no matching function for call to 'Foo2'}}