diff options
13 files changed, 120 insertions, 120 deletions
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 4e434a4063b..a1d2514d800 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -433,9 +433,9 @@ def note_strlcpycat_wrong_size : Note< def warn_memsize_comparison : Warning< "size argument in %0 call is a comparison">, InGroup<DiagGroup<"memsize-comparison">>; -def warn_memsize_comparison_paren_note : Note< +def note_memsize_comparison_paren : Note< "did you mean to compare the result of %0 instead?">; -def warn_memsize_comparison_cast_note : Note< +def note_memsize_comparison_cast_silence : Note< "explicitly cast the argument to size_t to silence this warning">; def warn_strncat_large_size : Warning< @@ -3953,8 +3953,8 @@ def warn_init_list_constant_narrowing : Warning< "constant expression evaluates to %0 which cannot be narrowed to type %1 in " "C++11">, InGroup<CXX11Narrowing>, DefaultIgnore; -def note_init_list_narrowing_override : Note< - "override this message by inserting an explicit cast">; +def note_init_list_narrowing_silence : Note< + "insert an explicit cast to silence this issue">; def err_init_objc_class : Error< "cannot initialize Objective-C class type %0">; def err_implicit_empty_initializer : Error< diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index ca7a92e0e11..7974b6f443e 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -3961,11 +3961,11 @@ static bool CheckMemorySizeofForComparison(Sema &S, const Expr *E, SourceRange SizeRange = Size->getSourceRange(); S.Diag(Size->getOperatorLoc(), diag::warn_memsize_comparison) << SizeRange << FnName; - S.Diag(FnLoc, diag::warn_memsize_comparison_paren_note) + S.Diag(FnLoc, diag::note_memsize_comparison_paren) << FnName << FixItHint::CreateInsertion( S.getLocForEndOfToken(Size->getLHS()->getLocEnd()), ")") << FixItHint::CreateRemoval(RParenLoc); - S.Diag(SizeRange.getBegin(), diag::warn_memsize_comparison_cast_note) + S.Diag(SizeRange.getBegin(), diag::note_memsize_comparison_cast_silence) << FixItHint::CreateInsertion(SizeRange.getBegin(), "(size_t)(") << FixItHint::CreateInsertion(S.getLocForEndOfToken(SizeRange.getEnd()), ")"); diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 77bc4d38d27..fe1f7c8e746 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -7054,7 +7054,7 @@ static void DiagnoseNarrowingInInitList(Sema &S, return; } OS << ">("; - S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_override) + S.Diag(PostInit->getLocStart(), diag::note_init_list_narrowing_silence) << PostInit->getSourceRange() << FixItHint::CreateInsertion(PostInit->getLocStart(), OS.str()) << FixItHint::CreateInsertion( diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/basic.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/basic.cpp index b30e0ec7856..b44b2c7d156 100644 --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/basic.cpp +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/basic.cpp @@ -8,9 +8,9 @@ namespace PR12453 { template<typename T> void f(int i) { T x{i}; // expected-error{{non-constant-expression cannot be narrowed from type 'int' to 'float' in initializer list}} \ - // expected-note{{override this message by inserting an explicit cast}} + // expected-note{{insert an explicit cast to silence this issue}} T y{i}; // expected-error{{non-constant-expression cannot be narrowed from type 'int' to 'float' in initializer list}} \ - // expected-note{{override this message by inserting an explicit cast}} + // expected-note{{insert an explicit cast to silence this issue}} } template void f<float>(int); // expected-note{{in instantiation of function template specialization 'PR12453::f<float>' requested here}} diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp index 58d038366c8..971e0c11aff 100644 --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p3-0x.cpp @@ -23,7 +23,7 @@ namespace std { namespace bullet1 { double ad[] = { 1, 2.0 }; - int ai[] = { 1, 2.0 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + int ai[] = { 1, 2.0 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} struct S2 { int m1; @@ -31,7 +31,7 @@ namespace bullet1 { }; S2 s21 = { 1, 2, 3.0 }; - S2 s22 { 1.0, 2, 3 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + S2 s22 { 1.0, 2, 3 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} S2 s23 { }; } @@ -62,13 +62,13 @@ namespace bullet4_example3 { }; S s1 = { 1, 2, 3.0 }; - S s2 { 1.0, 2, 3 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + S s2 { 1.0, 2, 3 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} S s3 {}; } namespace bullet5 { int x1 {2}; - int x2 {2.0}; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + int x2 {2.0}; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} } namespace bullet6 { @@ -81,7 +81,7 @@ namespace bullet6 { const S& r2 = { "Spinach" }; S& r3 = { 1, 2, 3 }; // expected-error {{non-const lvalue reference to type 'bullet6::S' cannot bind to an initializer list temporary}} const int& i1 = { 1 }; - const int& i2 = { 1.1 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} expected-warning {{implicit conversion}} + const int& i2 = { 1.1 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} expected-warning {{implicit conversion}} const int (&iar)[2] = { 1, 2 }; } @@ -92,20 +92,20 @@ namespace bullet7 { namespace bullet8 { struct A { int i; int j; }; A a1 { 1, 2 }; - A a2 { 1.2 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} expected-warning {{implicit conversion}} + A a2 { 1.2 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} expected-warning {{implicit conversion}} struct B { B(std::initializer_list<int> i) {} }; B b1 { 1, 2 }; - B b2 { 1, 2.0 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + B b2 { 1, 2.0 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} struct C { C(int i, double j) {} }; C c1 = { 1, 2.2 }; // FIXME: Suppress the narrowing warning in the cases where we issue a narrowing error. - C c2 = { 1.1, 2 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} expected-warning {{implicit conversion}} + C c2 = { 1.1, 2 }; // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} expected-warning {{implicit conversion}} int j { 1 }; int k { }; diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp index 0bea4ede19c..299611ba735 100644 --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x-fixits.cpp @@ -26,7 +26,7 @@ void test_template() { maybe_shrink_int((char)3); // CHECK: warning:{{.*}} cannot be narrowed // CHECK: note:{{.*}} in instantiation - // CHECK: note:{{.*}} override + // CHECK: note:{{.*}} silence // FIXME: This should be static_cast<T>. // CHECK: fix-it:{{.*}}"static_cast<char>(" // CHECK: fix-it:{{.*}}")" diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp index de2a76cbc9f..42dee92b3ca 100644 --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-0x.cpp @@ -8,16 +8,16 @@ void std_example() { const int y = 999; const int z = 99; char c1 = x; // OK, though it might narrow (in this case, it does narrow) - char c2{x}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - char c3{y}; // expected-error {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + char c2{x}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + char c3{y}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} char c4{z}; // OK: no narrowing needed unsigned char uc1 = {5}; // OK: no narrowing needed - unsigned char uc2 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - unsigned int ui1 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + unsigned char uc2 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + unsigned int ui1 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} signed int si1 = - { (unsigned int)-1 }; // expected-error {{ cannot be narrowed }} expected-note {{override}} - int ii = {2.0}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - float f1 { x }; // expected-error {{ cannot be narrowed }} expected-note {{override}} + { (unsigned int)-1 }; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + int ii = {2.0}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + float f1 { x }; // expected-error {{ cannot be narrowed }} expected-note {{silence}} float f2 { 7 }; // OK: 7 can be exactly represented as a float int f(int); int a[] = @@ -44,19 +44,19 @@ template<typename T> Convert<T> ConvertVar(); // * from a floating-point type to an integer type, or void float_to_int() { - Agg<char> a1 = {1.0F}; // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{override}} - Agg<char> a2 = {1.0}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a3 = {1.0L}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<char> a1 = {1.0F}; // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}} + Agg<char> a2 = {1.0}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a3 = {1.0L}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} float f = 1.0; double d = 1.0; long double ld = 1.0; - Agg<char> a4 = {f}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a5 = {d}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a6 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<char> a4 = {f}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a5 = {d}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a6 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} - Agg<char> ce1 = { Convert<float>(1.0) }; // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{override}} - Agg<char> ce2 = { ConvertVar<double>() }; // expected-error {{type 'double' cannot be narrowed to 'char'}} expected-note {{override}} + Agg<char> ce1 = { Convert<float>(1.0) }; // expected-error {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}} + Agg<char> ce2 = { ConvertVar<double>() }; // expected-error {{type 'double' cannot be narrowed to 'char'}} expected-note {{silence}} } // * from long double to double or float, or from double to float, except where @@ -72,8 +72,8 @@ void shrink_float() { // Variables. Agg<float> f1 = {f}; // OK (no-op) - Agg<float> f2 = {d}; // expected-error {{non-constant-expression cannot be narrowed from type 'double' to 'float'}} expected-note {{override}} - Agg<float> f3 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f2 = {d}; // expected-error {{non-constant-expression cannot be narrowed from type 'double' to 'float'}} expected-note {{silence}} + Agg<float> f3 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // Exact constants. Agg<float> f4 = {1.0}; // OK (double constant represented exactly) Agg<float> f5 = {1.0L}; // OK (long double constant represented exactly) @@ -81,8 +81,8 @@ void shrink_float() { Agg<float> f6 = {0.1}; // OK (double constant in range but rounded) Agg<float> f7 = {0.1L}; // OK (long double constant in range but rounded) // Out of range constants. - Agg<float> f8 = {1E50}; // expected-error {{constant expression evaluates to 1.000000e+50 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<float> f9 = {1E50L}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f8 = {1E50}; // expected-error {{constant expression evaluates to 1.000000e+50 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<float> f9 = {1E50L}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // More complex constant expression. constexpr long double e40 = 1E40L, e30 = 1E30L, e39 = 1E39L; Agg<float> f10 = {e40 - 5 * e39 + e30 - 5 * e39}; // OK @@ -90,19 +90,19 @@ void shrink_float() { // Variables. Agg<double> d1 = {f}; // OK (widening) Agg<double> d2 = {d}; // OK (no-op) - Agg<double> d3 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<double> d3 = {ld}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // Exact constant. Agg<double> d4 = {1.0L}; // OK (long double constant represented exactly) // Inexact but in-range constant. Agg<double> d5 = {0.1L}; // OK (long double constant in range but rounded) // Out of range constant. - Agg<double> d6 = {1E315L}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<double> d6 = {1E315L}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // More complex constant expression. constexpr long double e315 = 1E315L, e305 = 1E305L, e314 = 1E314L; Agg<double> d7 = {e315 - 5 * e314 + e305 - 5 * e314}; // OK - Agg<float> ce1 = { Convert<double>(1e300) }; // expected-error {{constant expression evaluates to 1.000000e+300 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<double> ce2 = { ConvertVar<long double>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long double' to 'double'}} expected-note {{override}} + Agg<float> ce1 = { Convert<double>(1e300) }; // expected-error {{constant expression evaluates to 1.000000e+300 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<double> ce2 = { ConvertVar<long double>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long double' to 'double'}} expected-note {{silence}} } // * from an integer type or unscoped enumeration type to a floating-point type, @@ -114,16 +114,16 @@ void int_to_float() { char c = 1; // Variables. Yes, even though all char's will fit into any floating type. - Agg<float> f1 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<double> f2 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<long double> f3 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f1 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<double> f2 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<long double> f3 = {c}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // Constants. Agg<float> f4 = {12345678}; // OK (exactly fits in a float) - Agg<float> f5 = {123456789}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f5 = {123456789}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} - Agg<float> ce1 = { Convert<int>(123456789) }; // expected-error {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<double> ce2 = { ConvertVar<long long>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{override}} + Agg<float> ce1 = { Convert<int>(123456789) }; // expected-error {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<double> ce2 = { ConvertVar<long long>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}} } // * from an integer type or unscoped enumeration type to an integer type that @@ -135,53 +135,53 @@ void shrink_int() { // Not a constant expression. short s = 1; unsigned short us = 1; - Agg<char> c1 = {s}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<unsigned short> s1 = {s}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<short> s2 = {us}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<char> c1 = {s}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<unsigned short> s1 = {s}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<short> s2 = {us}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // "that cannot represent all the values of the original type" means that the // validity of the program depends on the relative sizes of integral types. // This test compiles with -m64, so sizeof(int)<sizeof(long)==sizeof(long // long). long l1 = 1; - Agg<int> i1 = {l1}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<int> i1 = {l1}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} long long ll = 1; Agg<long> l2 = {ll}; // OK // Constants. Agg<char> c2 = {127}; // OK - Agg<char> c3 = {300}; // expected-error {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + Agg<char> c3 = {300}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} Agg<int> i2 = {0x7FFFFFFFU}; // OK - Agg<int> i3 = {0x80000000U}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<unsigned int> i4 = {-0x80000000L}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<int> i3 = {0x80000000U}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<unsigned int> i4 = {-0x80000000L}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // Bool is also an integer type, but conversions to it are a different AST // node. Agg<bool> b1 = {0}; // OK Agg<bool> b2 = {1}; // OK - Agg<bool> b3 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{override}} + Agg<bool> b3 = {-1}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} // Conversions from pointers to booleans aren't narrowing conversions. Agg<bool>* ptr = &b1; Agg<bool> b = {ptr}; // OK - Agg<short> ce1 = { Convert<int>(100000) }; // expected-error {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{override}} expected-warning {{changes value from 100000 to -31072}} - Agg<char> ce2 = { ConvertVar<short>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{override}} + Agg<short> ce1 = { Convert<int>(100000) }; // expected-error {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{silence}} expected-warning {{changes value from 100000 to -31072}} + Agg<char> ce2 = { ConvertVar<short>() }; // expected-error {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{silence}} // Negative -> larger unsigned type. - unsigned long long ll1 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{override}} + unsigned long long ll1 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}} unsigned long long ll2 = { 1 }; // OK - unsigned long long ll3 = { s }; // expected-error {{cannot be narrowed from type 'short'}} expected-note {{override}} + unsigned long long ll3 = { s }; // expected-error {{cannot be narrowed from type 'short'}} expected-note {{silence}} unsigned long long ll4 = { us }; // OK - unsigned long long ll5 = { ll }; // expected-error {{cannot be narrowed from type 'long long'}} expected-note {{override}} - Agg<unsigned long long> ll6 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{override}} + unsigned long long ll5 = { ll }; // expected-error {{cannot be narrowed from type 'long long'}} expected-note {{silence}} + Agg<unsigned long long> ll6 = { -1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}} Agg<unsigned long long> ll7 = { 18446744073709551615ULL }; // OK - Agg<unsigned long long> ll8 = { __int128(18446744073709551615ULL) + 1 }; // expected-error {{ 18446744073709551616 which cannot be narrowed}} expected-note {{override}} expected-warning {{changes value}} + Agg<unsigned long long> ll8 = { __int128(18446744073709551615ULL) + 1 }; // expected-error {{ 18446744073709551616 which cannot be narrowed}} expected-note {{silence}} expected-warning {{changes value}} signed char c = 'x'; - unsigned short usc1 = { c }; // expected-error {{non-constant-expression cannot be narrowed from type 'signed char'}} expected-note {{override}} + unsigned short usc1 = { c }; // expected-error {{non-constant-expression cannot be narrowed from type 'signed char'}} expected-note {{silence}} unsigned short usc2 = { (signed char)'x' }; // OK - unsigned short usc3 = { (signed char)-1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{override}} + unsigned short usc3 = { (signed char)-1 }; // expected-error {{ -1 which cannot be narrowed}} expected-note {{silence}} } // Be sure that type- and value-dependent expressions in templates get the error @@ -189,9 +189,9 @@ void shrink_int() { template<int I, typename T> void maybe_shrink_int(T t) { - Agg<short> s1 = {t}; // expected-error {{ cannot be narrowed }} expected-note {{override}} - Agg<short> s2 = {I}; // expected-error {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} - Agg<T> t2 = {700}; // expected-error {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + Agg<short> s1 = {t}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} + Agg<short> s2 = {I}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} + Agg<T> t2 = {700}; // expected-error {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} } void test_template() { @@ -204,9 +204,9 @@ void test_template() { void test_qualifiers(int i) { const int j = i; - struct {const unsigned char c;} c1 = {j}; // expected-error {{from type 'int' to 'unsigned char' in}} expected-note {{override}} + struct {const unsigned char c;} c1 = {j}; // expected-error {{from type 'int' to 'unsigned char' in}} expected-note {{silence}} // Template arguments make it harder to avoid printing qualifiers: - Agg<const unsigned char> c2 = {j}; // expected-error {{from type 'int' to 'const unsigned char' in}} expected-note {{override}} + Agg<const unsigned char> c2 = {j}; // expected-error {{from type 'int' to 'const unsigned char' in}} expected-note {{silence}} } // Test SFINAE checks. diff --git a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-cxx11-nowarn.cpp b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-cxx11-nowarn.cpp index cbeae4f0bb0..d4d8198d4fc 100644 --- a/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-cxx11-nowarn.cpp +++ b/clang/test/CXX/dcl.decl/dcl.init/dcl.init.list/p7-cxx11-nowarn.cpp @@ -9,16 +9,16 @@ void std_example() { const int y = 999; const int z = 99; char c1 = x; // OK, though it might narrow (in this case, it does narrow) - char c2{x}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - char c3{y}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + char c2{x}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + char c3{y}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} char c4{z}; // OK: no narrowing needed unsigned char uc1 = {5}; // OK: no narrowing needed - unsigned char uc2 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - unsigned int ui1 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + unsigned char uc2 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + unsigned int ui1 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} signed int si1 = - { (unsigned int)-1 }; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - int ii = {2.0}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - float f1 { x }; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + { (unsigned int)-1 }; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + int ii = {2.0}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + float f1 { x }; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} float f2 { 7 }; // OK: 7 can be exactly represented as a float int f(int); int a[] = @@ -45,19 +45,19 @@ template<typename T> Convert<T> ConvertVar(); // * from a floating-point type to an integer type, or void float_to_int() { - Agg<char> a1 = {1.0F}; // expected-warning {{type 'float' cannot be narrowed to 'char'}} expected-note {{override}} - Agg<char> a2 = {1.0}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a3 = {1.0L}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<char> a1 = {1.0F}; // expected-warning {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}} + Agg<char> a2 = {1.0}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a3 = {1.0L}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} float f = 1.0; double d = 1.0; long double ld = 1.0; - Agg<char> a4 = {f}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a5 = {d}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<char> a6 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<char> a4 = {f}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a5 = {d}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<char> a6 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} - Agg<char> ce1 = { Convert<float>(1.0) }; // expected-warning {{type 'float' cannot be narrowed to 'char'}} expected-note {{override}} - Agg<char> ce2 = { ConvertVar<double>() }; // expected-warning {{type 'double' cannot be narrowed to 'char'}} expected-note {{override}} + Agg<char> ce1 = { Convert<float>(1.0) }; // expected-warning {{type 'float' cannot be narrowed to 'char'}} expected-note {{silence}} + Agg<char> ce2 = { ConvertVar<double>() }; // expected-warning {{type 'double' cannot be narrowed to 'char'}} expected-note {{silence}} } // * from long double to double or float, or from double to float, except where @@ -73,8 +73,8 @@ void shrink_float() { // Variables. Agg<float> f1 = {f}; // OK (no-op) - Agg<float> f2 = {d}; // expected-warning {{non-constant-expression cannot be narrowed from type 'double' to 'float'}} expected-note {{override}} - Agg<float> f3 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f2 = {d}; // expected-warning {{non-constant-expression cannot be narrowed from type 'double' to 'float'}} expected-note {{silence}} + Agg<float> f3 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // Exact constants. Agg<float> f4 = {1.0}; // OK (double constant represented exactly) Agg<float> f5 = {1.0L}; // OK (long double constant represented exactly) @@ -82,8 +82,8 @@ void shrink_float() { Agg<float> f6 = {0.1}; // OK (double constant in range but rounded) Agg<float> f7 = {0.1L}; // OK (long double constant in range but rounded) // Out of range constants. - Agg<float> f8 = {1E50}; // expected-warning {{constant expression evaluates to 1.000000e+50 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<float> f9 = {1E50L}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f8 = {1E50}; // expected-warning {{constant expression evaluates to 1.000000e+50 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<float> f9 = {1E50L}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // More complex constant expression. constexpr long double e40 = 1E40L, e30 = 1E30L, e39 = 1E39L; Agg<float> f10 = {e40 - 5 * e39 + e30 - 5 * e39}; // OK @@ -91,19 +91,19 @@ void shrink_float() { // Variables. Agg<double> d1 = {f}; // OK (widening) Agg<double> d2 = {d}; // OK (no-op) - Agg<double> d3 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<double> d3 = {ld}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // Exact constant. Agg<double> d4 = {1.0L}; // OK (long double constant represented exactly) // Inexact but in-range constant. Agg<double> d5 = {0.1L}; // OK (long double constant in range but rounded) // Out of range constant. - Agg<double> d6 = {1E315L}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<double> d6 = {1E315L}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // More complex constant expression. constexpr long double e315 = 1E315L, e305 = 1E305L, e314 = 1E314L; Agg<double> d7 = {e315 - 5 * e314 + e305 - 5 * e314}; // OK - Agg<float> ce1 = { Convert<double>(1e300) }; // expected-warning {{constant expression evaluates to 1.000000e+300 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<double> ce2 = { ConvertVar<long double>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'long double' to 'double'}} expected-note {{override}} + Agg<float> ce1 = { Convert<double>(1e300) }; // expected-warning {{constant expression evaluates to 1.000000e+300 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<double> ce2 = { ConvertVar<long double>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'long double' to 'double'}} expected-note {{silence}} } // * from an integer type or unscoped enumeration type to a floating-point type, @@ -115,16 +115,16 @@ void int_to_float() { char c = 1; // Variables. Yes, even though all char's will fit into any floating type. - Agg<float> f1 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<double> f2 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<long double> f3 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f1 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<double> f2 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<long double> f3 = {c}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // Constants. Agg<float> f4 = {12345678}; // OK (exactly fits in a float) - Agg<float> f5 = {123456789}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<float> f5 = {123456789}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} - Agg<float> ce1 = { Convert<int>(123456789) }; // expected-warning {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{override}} - Agg<double> ce2 = { ConvertVar<long long>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{override}} + Agg<float> ce1 = { Convert<int>(123456789) }; // expected-warning {{constant expression evaluates to 123456789 which cannot be narrowed to type 'float'}} expected-note {{silence}} + Agg<double> ce2 = { ConvertVar<long long>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'long long' to 'double'}} expected-note {{silence}} } // * from an integer type or unscoped enumeration type to an integer type that @@ -136,39 +136,39 @@ void shrink_int() { // Not a constant expression. short s = 1; unsigned short us = 1; - Agg<char> c1 = {s}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<unsigned short> s1 = {s}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<short> s2 = {us}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<char> c1 = {s}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<unsigned short> s1 = {s}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<short> s2 = {us}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // "that cannot represent all the values of the original type" means that the // validity of the program depends on the relative sizes of integral types. // This test compiles with -m64, so sizeof(int)<sizeof(long)==sizeof(long // long). long l1 = 1; - Agg<int> i1 = {l1}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<int> i1 = {l1}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} long long ll = 1; Agg<long> l2 = {ll}; // OK // Constants. Agg<char> c2 = {127}; // OK - Agg<char> c3 = {300}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + Agg<char> c3 = {300}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} Agg<int> i2 = {0x7FFFFFFFU}; // OK - Agg<int> i3 = {0x80000000U}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<unsigned int> i4 = {-0x80000000L}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<int> i3 = {0x80000000U}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<unsigned int> i4 = {-0x80000000L}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // Bool is also an integer type, but conversions to it are a different AST // node. Agg<bool> b1 = {0}; // OK Agg<bool> b2 = {1}; // OK - Agg<bool> b3 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} + Agg<bool> b3 = {-1}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} // Conversions from pointers to booleans aren't narrowing conversions. Agg<bool>* ptr = &b1; Agg<bool> b = {ptr}; // OK - Agg<short> ce1 = { Convert<int>(100000) }; // expected-warning {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{override}} expected-warning {{changes value from 100000 to -31072}} - Agg<char> ce2 = { ConvertVar<short>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{override}} + Agg<short> ce1 = { Convert<int>(100000) }; // expected-warning {{constant expression evaluates to 100000 which cannot be narrowed to type 'short'}} expected-note {{silence}} expected-warning {{changes value from 100000 to -31072}} + Agg<char> ce2 = { ConvertVar<short>() }; // expected-warning {{non-constant-expression cannot be narrowed from type 'short' to 'char'}} expected-note {{silence}} } // Be sure that type- and value-dependent expressions in templates get the warning @@ -176,9 +176,9 @@ void shrink_int() { template<int I, typename T> void maybe_shrink_int(T t) { - Agg<short> s1 = {t}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} - Agg<short> s2 = {I}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} - Agg<T> t2 = {700}; // expected-warning {{ cannot be narrowed }} expected-note {{override}} expected-warning {{changes value}} + Agg<short> s1 = {t}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} + Agg<short> s2 = {I}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} + Agg<T> t2 = {700}; // expected-warning {{ cannot be narrowed }} expected-note {{silence}} expected-warning {{changes value}} } void test_template() { @@ -191,9 +191,9 @@ void test_template() { void test_qualifiers(int i) { const int j = i; - struct {const unsigned char c;} c1 = {j}; // expected-warning {{from type 'int' to 'unsigned char' in}} expected-note {{override}} + struct {const unsigned char c;} c1 = {j}; // expected-warning {{from type 'int' to 'unsigned char' in}} expected-note {{silence}} // Template arguments make it harder to avoid printing qualifiers: - Agg<const unsigned char> c2 = {j}; // expected-warning {{from type 'int' to 'const unsigned char' in}} expected-note {{override}} + Agg<const unsigned char> c2 = {j}; // expected-warning {{from type 'int' to 'const unsigned char' in}} expected-note {{silence}} } // Make sure we still get the right SFINAE behavior. diff --git a/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp index 2b443fce781..75b2341f3b6 100644 --- a/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp +++ b/clang/test/SemaCXX/cxx0x-initializer-constructor.cpp @@ -75,8 +75,8 @@ namespace objects { { F<0> f = {}; } // Narrowing conversions don't affect viability. The next two choose // the initializer_list constructor. - { F<3> f{1, 1.0}; } // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} - { F<3> f = {1, 1.0}; } // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{override}} + { F<3> f{1, 1.0}; } // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} + { F<3> f = {1, 1.0}; } // expected-error {{type 'double' cannot be narrowed to 'int' in initializer list}} expected-note {{silence}} { F<3> f{1, 2, 3, 4, 5, 6, 7, 8}; } { F<3> f = {1, 2, 3, 4, 5, 6, 7, 8}; } { F<3> f{1, 2, 3, 4, 5, 6, 7, 8}; } diff --git a/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp b/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp index 627855e96e8..1475dcf911c 100644 --- a/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp +++ b/clang/test/SemaCXX/cxx0x-initializer-scalars.cpp @@ -45,8 +45,8 @@ namespace integral { { const int a{1, 2}; } // expected-error {{excess elements}} { const int a = {1, 2}; } // expected-error {{excess elements}} // FIXME: Redundant warnings. - { const short a{100000}; } // expected-error {{cannot be narrowed}} expected-note {{inserting an explicit cast}} expected-warning {{changes value}} - { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{inserting an explicit cast}} expected-warning {{changes value}} + { const short a{100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}} + { const short a = {100000}; } // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast}} expected-warning {{changes value}} { if (const int a{1}) static_assert(a == 1, ""); } { if (const int a = {1}) static_assert(a == 1, ""); } } diff --git a/clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp b/clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp index 1ff64b334ae..4e62941e681 100644 --- a/clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp +++ b/clang/test/SemaCXX/cxx1y-variable-templates_top_level.cpp @@ -324,7 +324,7 @@ namespace narrowing { template<typename T> T v = {1234}; // expected-warning {{implicit conversion from 'int' to 'char' changes value from 1234 to}} #ifndef PRECXX11 // expected-error@-2 {{constant expression evaluates to 1234 which cannot be narrowed to type 'char'}}\ - // expected-note@-2 {{override this message by inserting an explicit cast}} + // expected-note@-2 {{insert an explicit cast to silence this issue}} #endif int k = v<char>; // expected-note {{in instantiation of variable template specialization 'narrowing::v<char>' requested here}} } diff --git a/clang/test/SemaCXX/microsoft-cxx0x.cpp b/clang/test/SemaCXX/microsoft-cxx0x.cpp index 79bd7c39e5a..58ab940f583 100644 --- a/clang/test/SemaCXX/microsoft-cxx0x.cpp +++ b/clang/test/SemaCXX/microsoft-cxx0x.cpp @@ -6,7 +6,7 @@ struct A { unsigned int a; }; int b = 3; -A var = { b }; // expected-warning {{ cannot be narrowed }} expected-note {{override}} +A var = { b }; // expected-warning {{ cannot be narrowed }} expected-note {{insert an explicit cast to silence this issue}} namespace PR13433 { diff --git a/clang/test/SemaTemplate/constexpr-instantiate.cpp b/clang/test/SemaTemplate/constexpr-instantiate.cpp index 95d6c23b9e9..e8e3e7dd5a0 100644 --- a/clang/test/SemaTemplate/constexpr-instantiate.cpp +++ b/clang/test/SemaTemplate/constexpr-instantiate.cpp @@ -154,7 +154,7 @@ namespace Unevaluated { constexpr S2() {} constexpr operator int() const { return 123456; } }; - int k2 = sizeof(short{S2(S2())}); // expected-error {{cannot be narrowed}} expected-note {{override}} + int k2 = sizeof(short{S2(S2())}); // expected-error {{cannot be narrowed}} expected-note {{insert an explicit cast to silence this issue}} } namespace PR12288 { |
