Author: Marcel Jacobse Date: 2025-09-24T18:33:27Z New Revision: 3cc56dd82a78964ab0b5edc9738abf90f259e36a
URL: https://github.com/llvm/llvm-project/commit/3cc56dd82a78964ab0b5edc9738abf90f259e36a DIFF: https://github.com/llvm/llvm-project/commit/3cc56dd82a78964ab0b5edc9738abf90f259e36a.diff LOG: [Clang] [Sema] Fix -Wdouble-promotion in C++ list-initialization (#159992) Resolves https://github.com/llvm/llvm-project/issues/33409. The information `IsListInit` is already passed to function `CheckImplicitConversion` for another use-case which makes adding a condition for the double-promotion case simple. Also adds tests, both for the changed list-initialization case as well as for normal explicit casts which already would have passed before this PR. These negative tests are added directly next to the positive tests in `warn-double-promotion.c` or for the C++-specific cases in a new .cpp version of that file. Added: clang/test/Sema/warn-double-promotion.cpp Modified: clang/docs/ReleaseNotes.rst clang/lib/Sema/SemaChecking.cpp clang/test/Sema/warn-double-promotion.c Removed: ################################################################################ diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 70c82b090107a..1dd6ea4d89173 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -422,6 +422,7 @@ Bug Fixes to C++ Support ``__builtin_addressof``, and related issues with builtin arguments. (#GH154034) - Fix an assertion failure when taking the address on a non-type template parameter argument of object type. (#GH151531) +- Suppress ``-Wdouble-promotion`` when explicitly asked for with C++ list initialization (#GH33409). Bug Fixes to AST Handling ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index e73e81c440cc1..2509453f417e2 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -13043,7 +13043,19 @@ static void AnalyzeImplicitConversions( // Skip past explicit casts. if (auto *CE = dyn_cast<ExplicitCastExpr>(E)) { - E = CE->getSubExpr()->IgnoreParenImpCasts(); + E = CE->getSubExpr(); + // In the special case of a C++ function-style cast with braces, + // CXXFunctionalCastExpr has an InitListExpr as direct child with a single + // initializer. This InitListExpr basically belongs to the cast itself, so + // we skip it too. Specifically this is needed to silence -Wdouble-promotion + if (isa<CXXFunctionalCastExpr>(CE)) { + if (auto *InitListE = dyn_cast<InitListExpr>(E)) { + if (InitListE->getNumInits() == 1) { + E = InitListE->getInit(0); + } + } + } + E = E->IgnoreParenImpCasts(); if (!CE->getType()->isVoidType() && E->getType()->isAtomicType()) S.Diag(E->getBeginLoc(), diag::warn_atomic_implicit_seq_cst); WorkList.push_back({E, CC, IsListInit}); diff --git a/clang/test/Sema/warn-double-promotion.c b/clang/test/Sema/warn-double-promotion.c index 5742a4fb3cbd4..7b06658bf4cdf 100644 --- a/clang/test/Sema/warn-double-promotion.c +++ b/clang/test/Sema/warn-double-promotion.c @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -triple x86_64-apple-darwin -verify -fsyntax-only %s -Wdouble-promotion +// RUN: %clang_cc1 -triple x86_64-apple-darwin -verify -fsyntax-only -x c++ %s -Wdouble-promotion float ReturnFloatFromDouble(double d) { return d; @@ -24,15 +25,39 @@ long double ReturnLongDoubleFromDouble(double d) { return d; //expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} } +double ReturnDoubleFromFloatWithExplicitCast(float f) { + return (double)f; +} + +long double ReturnLongDoubleFromFloatWithExplicitCast(float f) { + return (long double)f; +} + +long double ReturnLongDoubleFromDoubleWithExplicitCast(double d) { + return (long double)d; +} + void Assignment(float f, double d, long double ld) { d = f; //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} ld = f; //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} ld = d; //expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + d = (double)f; + ld = (long double)f; + ld = (long double)d; f = d; f = ld; d = ld; } +void AssignmentWithExtraParens(float f, double d, long double ld) { + d = (f); //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + ld = (f); //expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + ld = (d); //expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + d = (double)(f); + ld = (long double)(f); + ld = (long double)(d); +} + extern void DoubleParameter(double); extern void LongDoubleParameter(long double); @@ -40,6 +65,9 @@ void ArgumentPassing(float f, double d) { DoubleParameter(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} LongDoubleParameter(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} LongDoubleParameter(d); // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + DoubleParameter((double)f); + LongDoubleParameter((long double)f); + LongDoubleParameter((long double)d); } void BinaryOperator(float f, double d, long double ld) { @@ -49,12 +77,21 @@ void BinaryOperator(float f, double d, long double ld) { f = ld * f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} d = d * ld; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} d = ld * d; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + f = (double)f * d; + f = d * (double)f; + f = (long double)f * ld; + f = ld * (long double)f; + d = (long double)d * ld; + d = ld * (long double)d; } void MultiplicationAssignment(float f, double d, long double ld) { d *= f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} ld *= f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} ld *= d; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + d *= (double)f; + ld *= (long double)f; + ld *= (long double)d; // FIXME: These cases should produce warnings as above. f *= d; diff --git a/clang/test/Sema/warn-double-promotion.cpp b/clang/test/Sema/warn-double-promotion.cpp new file mode 100644 index 0000000000000..886911244fbd7 --- /dev/null +++ b/clang/test/Sema/warn-double-promotion.cpp @@ -0,0 +1,256 @@ +// RUN: %clang_cc1 -triple x86_64-apple-darwin -verify -fsyntax-only %s -Wdouble-promotion + +using LongDouble = long double; + +double ReturnDoubleFromFloatWithExplicitCast(float f) { + return static_cast<double>(f); +} + +long double ReturnLongDoubleFromFloatWithExplicitCast(float f) { + return static_cast<long double>(f); +} + +long double ReturnLongDoubleFromDoubleWithExplicitCast(double d) { + return static_cast<long double>(d); +} + +double ReturnDoubleFromFloatWithExplicitListInitialization(float f) { + return double{f}; +} + +long double ReturnLongDoubleFromFloatWithExplicitListInitialization(float f) { + return LongDouble{f}; +} + +long double ReturnLongDoubleFromDoubleWithExplicitListInitialization(double d) { + return LongDouble{d}; +} + +double ReturnDoubleFromFloatWithFunctionStyleCast(float f) { + return double(f); +} + +long double ReturnLongDoubleFromFloatWithFunctionStyleCast(float f) { + return LongDouble(f); +} + +long double ReturnLongDoubleFromDoubleWithFunctionStyleCast(double d) { + return LongDouble(d); +} + +void InitializationWithParens(float f, double d) { + { + double d(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + long double ld0(f); // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + long double ld1(d); // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + } + { + double d(static_cast<double>(f)); + long double ld0(static_cast<long double>(f)); + long double ld1(static_cast<long double>(d)); + } + { + double d(double{f}); + long double ld0(LongDouble{f}); + long double ld1(LongDouble{d}); + } + { + double d((double(f))); + long double ld0((LongDouble(f))); + long double ld1((LongDouble(d))); + } +} + +void InitializationWithBraces(float f, double d) { + { + double d{f}; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + long double ld0{f}; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + long double ld1{d}; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + } + { + double d{static_cast<double>(f)}; + long double ld0{static_cast<long double>(f)}; + long double ld1{static_cast<long double>(d)}; + } + { + double d{double{f}}; + long double ld0{LongDouble{f}}; + long double ld1{LongDouble{d}}; + } + { + double d{double(f)}; + long double ld0{LongDouble(f)}; + long double ld1{LongDouble(d)}; + } +} + +void Assignment(float f, double d, long double ld) { + d = static_cast<double>(f); + ld = static_cast<long double>(f); + ld = static_cast<long double>(d); + d = double{f}; + ld = LongDouble{f}; + ld = LongDouble{d}; + d = double(f); + ld = LongDouble(f); + ld = LongDouble(d); +} + +void AssignmentWithExtraParens(float f, double d, long double ld) { + d = static_cast<double>((f)); + ld = static_cast<long double>((f)); + ld = static_cast<long double>((d)); + d = double{(f)}; + ld = LongDouble{(f)}; + ld = LongDouble{(d)}; + d = double((f)); + ld = LongDouble((f)); + ld = LongDouble((d)); +} + +void AssignmentWithExtraBraces(float f, double d, long double ld) { + d = double{{f}}; // expected-warning{{too many braces around scalar initializer}} + ld = LongDouble{{f}}; // expected-warning{{too many braces around scalar initializer}} + ld = LongDouble{{d}}; // expected-warning{{too many braces around scalar initializer}} +} + +extern void DoubleParameter(double); +extern void LongDoubleParameter(long double); + +void ArgumentPassing(float f, double d) { + DoubleParameter(static_cast<double>(f)); + LongDoubleParameter(static_cast<long double>(f)); + LongDoubleParameter(static_cast<long double>(d)); + DoubleParameter(double{f}); + LongDoubleParameter(LongDouble{f}); + LongDoubleParameter(LongDouble{d}); + DoubleParameter(double(f)); + LongDoubleParameter(LongDouble(f)); + LongDoubleParameter(LongDouble(d)); +} + +void BinaryOperator(float f, double d, long double ld) { + f = static_cast<double>(f) * d; + f = d * static_cast<double>(f); + f = static_cast<long double>(f) * ld; + f = ld * static_cast<long double>(f); + d = static_cast<long double>(d) * ld; + d = ld * static_cast<long double>(d); + f = double{f} * d; + f = d * double{f}; + f = LongDouble{f} * ld; + f = ld * LongDouble{f}; + d = LongDouble{d} * ld; + d = ld * LongDouble{d}; + f = double(f) * d; + f = d * double(f); + f = LongDouble(f) * ld; + f = ld * LongDouble(f); + d = LongDouble(d) * ld; + d = ld * LongDouble(d); +} + +void MultiplicationAssignment(float f, double d, long double ld) { + d *= static_cast<double>(f); + ld *= static_cast<long double>(f); + ld *= static_cast<long double>(d); + d *= double{f}; + ld *= LongDouble{f}; + ld *= LongDouble{d}; + d *= double(f); + ld *= LongDouble(f); + ld *= LongDouble(d); +} + +struct ConstructWithDouble { + ConstructWithDouble(double); +}; + +struct ConstructWithLongDouble { + ConstructWithLongDouble(long double); +}; + +void Construct(float f, double d) { + ConstructWithDouble{f}; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + ConstructWithLongDouble{f}; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + ConstructWithLongDouble{d}; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + ConstructWithDouble{static_cast<double>(f)}; + ConstructWithLongDouble{static_cast<long double>(f)}; + ConstructWithLongDouble{static_cast<long double>(d)}; + ConstructWithDouble{double{f}}; + ConstructWithLongDouble{LongDouble{f}}; + ConstructWithLongDouble{LongDouble{d}}; + ConstructWithDouble{double(f)}; + ConstructWithLongDouble{LongDouble(f)}; + ConstructWithLongDouble{LongDouble(d)}; +} + +template <class T> T ReturnTFromFloat(float f) { + return f; // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} \ + // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} +} + +template <class T> T ReturnTFromDouble(double d) { + return d; // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} +} + +template <class T> T ReturnTFromFloatWithStaticCast(float f) { + return static_cast<T>(f); +} + +template <class T> T ReturnTFromDoubleWithStaticCast(double d) { + return static_cast<T>(d); +} + +template <class T> T ReturnTFromFloatWithExplicitListInitialization(float f) { + return T{f}; +} + +template <class T> T ReturnTFromDoubleWithExplicitListInitialization(double d) { + return T{d}; +} + +template <class T> T ReturnTFromFloatWithFunctionStyleCast(float f) { + return T(f); +} + +template <class T> T ReturnTFromDoubleWithFunctionStyleCast(double d) { + return T(d); +} + +void TestTemplate(float f, double d) { + ReturnTFromFloat<double>(f); // expected-note{{in instantiation of function template specialization 'ReturnTFromFloat<double>' requested here}} + ReturnTFromFloat<long double>(f); // expected-note{{in instantiation of function template specialization 'ReturnTFromFloat<long double>' requested here}} + ReturnTFromDouble<long double>(d); // expected-note{{in instantiation of function template specialization 'ReturnTFromDouble<long double>' requested here}} + ReturnTFromFloatWithStaticCast<double>(f); + ReturnTFromFloatWithStaticCast<long double>(f); + ReturnTFromDoubleWithStaticCast<long double>(d); + ReturnTFromFloatWithExplicitListInitialization<double>(f); + ReturnTFromFloatWithExplicitListInitialization<long double>(f); + ReturnTFromDoubleWithExplicitListInitialization<long double>(d); + ReturnTFromFloatWithFunctionStyleCast<double>(f); + ReturnTFromFloatWithFunctionStyleCast<long double>(f); + ReturnTFromDoubleWithFunctionStyleCast<long double>(d); +} + +struct MemberInitializerListParens { + double m_d; + long double m_ld0; + long double m_ld1; + MemberInitializerListParens(float f, double d): + m_d(f), // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + m_ld0(f), // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + m_ld1(d) // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + {} +}; + +struct MemberInitializerListBraces { + double m_d; + long double m_ld0; + long double m_ld1; + MemberInitializerListBraces(float f, double d): + m_d{f}, // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'double'}} + m_ld0{f}, // expected-warning{{implicit conversion increases floating-point precision: 'float' to 'long double'}} + m_ld1{d} // expected-warning{{implicit conversion increases floating-point precision: 'double' to 'long double'}} + {} +}; _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
