https://github.com/philnik777 updated https://github.com/llvm/llvm-project/pull/200675
>From 5654616dd0909975ce07fdd7db187374ff2dedd8 Mon Sep 17 00:00:00 2001 From: Nikolas Klauser <[email protected]> Date: Sun, 31 May 2026 19:16:13 +0200 Subject: [PATCH 1/5] [Clang] Accept auto casts pre-C++23 as an extension --- clang/docs/LanguageExtensions.rst | 1 + .../clang/Basic/DiagnosticSemaKinds.td | 5 +-- clang/lib/Frontend/InitPreprocessor.cpp | 2 +- clang/lib/Parse/ParseTentative.cpp | 2 - clang/lib/Sema/SemaExprCXX.cpp | 7 ++- clang/lib/Sema/SemaType.cpp | 11 +++-- .../dcl.spec/dcl.type/dcl.spec.auto/p5.cpp | 4 +- .../dcl.type/dcl.type.auto.deduct/p2.cpp | 43 ++++++++++--------- .../expr/expr.post/expr.type.conv/p1-2b.cpp | 37 ++++++++-------- clang/test/Lexer/cxx-features.cpp | 2 +- clang/test/Parser/cxx1z-decomposition.cpp | 5 +-- clang/test/Parser/cxx2b-auto-x.cpp | 25 +++++------ 12 files changed, 68 insertions(+), 76 deletions(-) diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index fbb9947f39d3e..1ecc8c01a5f8e 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -1978,6 +1978,7 @@ Pack Indexing __cpp_pack_indexing C ``= delete ("should have a reason");`` __cpp_deleted_function C++26 C++03 Variadic Friends __cpp_variadic_friend C++26 C++03 Trivial Relocatability __cpp_trivial_relocatability C++26 C++03 +``auto()`` cast __cpp_auto_cast C++26 C++03 --------------------------------------------- -------------------------------- ------------- ------------- Designated initializers (N494) C99 C89 ``_Complex`` (N693) C99 C89, C++ diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 077aace321264..859eabe97b4c4 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -59,6 +59,8 @@ defm constexpr_static_var : CXX23Compat< "in a constexpr %select{function|constructor}0 " "is">; +defm auto_expr : CXX23Compat<"'auto' as a functional-style cast is">; + // C++26 compatibility with C++23 and earlier. defm decomp_decl_cond : CXX26Compat<"structured binding declaration in a condition is">; @@ -2702,9 +2704,6 @@ def err_auto_new_ctor_multiple_expressions : Error< def err_auto_expr_init_paren_braces : Error< "cannot deduce actual type for %1 from " "%select{parenthesized|nested}0 initializer list">; -def warn_cxx20_compat_auto_expr : Warning< - "'auto' as a functional-style cast is incompatible with C++ standards " - "before C++23">, InGroup<CXXPre23Compat>, DefaultIgnore; def err_auto_missing_trailing_return : Error< "'auto' return without trailing return type; deduced return types are a " "C++14 extension">; diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 3f0468a938149..448cb551cc930 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -735,7 +735,6 @@ static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, Builder.defineMacro("__cpp_size_t_suffix", "202011L"); Builder.defineMacro("__cpp_if_consteval", "202106L"); Builder.defineMacro("__cpp_multidimensional_subscript", "202211L"); - Builder.defineMacro("__cpp_auto_cast", "202110L"); Builder.defineMacro("__cpp_explicit_this_parameter", "202110L"); } @@ -743,6 +742,7 @@ static void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts, // we also define their feature test macros. if (LangOpts.CPlusPlus11) Builder.defineMacro("__cpp_static_call_operator", "202207L"); + Builder.defineMacro("__cpp_auto_cast", "202110L"); Builder.defineMacro("__cpp_named_character_escapes", "202207L"); Builder.defineMacro("__cpp_placeholder_variables", "202306L"); diff --git a/clang/lib/Parse/ParseTentative.cpp b/clang/lib/Parse/ParseTentative.cpp index f77b1001332fe..74180cf2ddeaf 100644 --- a/clang/lib/Parse/ParseTentative.cpp +++ b/clang/lib/Parse/ParseTentative.cpp @@ -1143,8 +1143,6 @@ Parser::isCXXDeclarationSpecifier(ImplicitTypenameContext AllowImplicitTypename, BracedCastResult, InvalidAsDeclSpec); case tok::kw_auto: { - if (!getLangOpts().CPlusPlus23) - return TPResult::True; if (NextToken().is(tok::l_brace)) return TPResult::False; if (NextToken().is(tok::l_paren)) diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 00c873833c8a7..22b1d62cfaa06 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -1560,6 +1560,9 @@ Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits()); } + if (Ty->getAs<AutoType>()) + DiagCompat(TyBeginLoc, diag_compat::auto_expr) << FullRange; + if (Inits.empty()) return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression) << Ty << FullRange); @@ -1569,10 +1572,6 @@ Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, diag::err_auto_expr_init_multiple_expressions) << Ty << FullRange); } - if (getLangOpts().CPlusPlus23) { - if (Ty->getAs<AutoType>()) - Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange; - } Expr *Deduce = Inits[0]; if (isa<InitListExpr>(Deduce)) return ExprError( diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 44ac4f6630690..9e8abee1e2d44 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -3251,6 +3251,10 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, DeducedIsTrailingReturnType = true; } + SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc(); + if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId) + AutoRange = D.getName().getSourceRange(); + // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context. if (Deduced) { AutoType *Auto = dyn_cast<AutoType>(Deduced); @@ -3382,8 +3386,7 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, case DeclaratorContext::FunctionalCast: if (isa<DeducedTemplateSpecializationType>(Deduced)) break; - if (SemaRef.getLangOpts().CPlusPlus23 && IsCXXAutoType && - !Auto->isDecltypeAuto()) + if (IsCXXAutoType && !Auto->isDecltypeAuto()) break; // auto(x) [[fallthrough]]; case DeclaratorContext::TypeName: @@ -3419,10 +3422,6 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, (!SemaRef.getLangOpts().CPlusPlus11 || !IsCXXAutoType)) Error = 13; - SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc(); - if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId) - AutoRange = D.getName().getSourceRange(); - if (Error != -1) { unsigned Kind; if (Auto) { diff --git a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp index 9571d6670e70d..bdf3a587a7c52 100644 --- a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp +++ b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p5.cpp @@ -56,8 +56,8 @@ void j() { (void)reinterpret_cast<auto>(n); // expected-error{{'auto' not allowed here}} (void)const_cast<auto>(n); // expected-error{{'auto' not allowed here}} (void)(auto)(n); // expected-error{{'auto' not allowed here}} - (void)auto(n); // expected-error{{'auto' not allowed here}} - (void)auto{n}; // expected-error{{'auto' not allowed here}} + (void)auto(n); // expected-warning{{'auto' as a functional-style cast is a C++23 extension}} + (void)auto{n}; // expected-warning{{'auto' as a functional-style cast is a C++23 extension}} } template <auto a = 10> class C { }; // expected-error{{'auto' not allowed in template parameter}} diff --git a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp index 1655685f44808..1c6c66882c570 100644 --- a/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp +++ b/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp @@ -1,37 +1,38 @@ +// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20 %s // RUN: %clang_cc1 -std=c++23 -verify %s // p2.3 allows only T = auto in T(x). void test_decay() { int v[3]; - static_assert(__is_same(decltype(auto(v)), int *)); - static_assert(__is_same(decltype(auto{v}), int *)); - static_assert(__is_same(decltype(auto("lit")), char const *)); - static_assert(__is_same(decltype(auto{"lit"}), char const *)); + static_assert(__is_same(decltype(auto(v)), int *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto{v}), int *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto("lit")), char const *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto{"lit"}), char const *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} constexpr long i = 1; static_assert(__is_same(decltype(i), long const)); - static_assert(__is_same(decltype(auto(1L)), long)); - static_assert(__is_same(decltype(auto{1L}), long)); - static_assert(__is_same(decltype(auto(i)), long)); - static_assert(__is_same(decltype(auto{i}), long)); + static_assert(__is_same(decltype(auto(1L)), long)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto{1L}), long)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(i)), long)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto{i}), long)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} class A { } a; A const ac; - static_assert(__is_same(decltype(auto(a)), A)); - static_assert(__is_same(decltype(auto(ac)), A)); + static_assert(__is_same(decltype(auto(a)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(ac)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} A &lr = a; A const &lrc = a; A &&rr = static_cast<A &&>(a); A const &&rrc = static_cast<A &&>(a); - static_assert(__is_same(decltype(auto(lr)), A)); - static_assert(__is_same(decltype(auto(lrc)), A)); - static_assert(__is_same(decltype(auto(rr)), A)); - static_assert(__is_same(decltype(auto(rrc)), A)); + static_assert(__is_same(decltype(auto(lr)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(lrc)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(rr)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(rrc)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} } class cmdline_parser { @@ -42,7 +43,7 @@ class cmdline_parser { void test_rvalue_fluent_interface() { auto cmdline = cmdline_parser("driver"); - auto internal = auto{cmdline}.add_option("--dump-full", "do not minimize dump"); + auto internal = auto{cmdline}.add_option("--dump-full", "do not minimize dump"); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} } template <class T> constexpr auto decay_copy(T &&v) { return static_cast<T &&>(v); } // expected-error {{calling a protected constructor}} @@ -55,17 +56,17 @@ class A { A(); auto test_access() { - static_assert(__is_same(decltype(auto(*this)), A)); - static_assert(__is_same(decltype(auto(this)), A *)); + static_assert(__is_same(decltype(auto(*this)), A)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(this)), A *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} f(A(*this)); // ok - f(auto(*this)); // ok in P0849 + f(auto(*this)); // ok in P0849 cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} f(decay_copy(*this)); // expected-note {{in instantiation of function template specialization}} } auto test_access() const { - static_assert(__is_same(decltype(auto(*this)), A)); // ditto - static_assert(__is_same(decltype(auto(this)), A const *)); + static_assert(__is_same(decltype(auto(*this)), A)); // ditto cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + static_assert(__is_same(decltype(auto(this)), A const *)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} } protected: @@ -77,5 +78,5 @@ namespace auto_x { constexpr struct Uncopyable { constexpr explicit Uncopyable(int) {} constexpr Uncopyable(Uncopyable &&) = delete; -} u = auto(Uncopyable(auto(Uncopyable(42)))); +} u = auto(Uncopyable(auto(Uncopyable(42)))); // cxx20-warning 2 {{'auto' as a functional-style cast is a C++23 extension}} } // namespace auto_x diff --git a/clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp b/clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp index bbfce5e698d15..08560ea19c9c7 100644 --- a/clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp +++ b/clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp @@ -1,3 +1,4 @@ +// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx20 %s // RUN: %clang_cc1 -std=c++23 -verify %s template <class T> @@ -12,28 +13,28 @@ struct A { // C++23 [dcl.type.auto.deduct]p2.3 // For an explicit type conversion, T is the specified type, which shall be auto. void diagnostics() { - foo(auto()); // expected-error {{initializer for functional-style cast to 'auto' is empty}} - foo(auto{}); // expected-error {{initializer for functional-style cast to 'auto' is empty}} - foo(auto({})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} - foo(auto{{}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} + foo(auto()); // expected-error {{initializer for functional-style cast to 'auto' is empty}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{}); // expected-error {{initializer for functional-style cast to 'auto' is empty}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto({})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{{}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} // - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression. - foo(auto(a)); + foo(auto(a)); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} // - If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression. - foo(auto{a}); - foo(auto({a})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} - foo(auto{{a}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} + foo(auto{a}); // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto({a})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{{a}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} - foo(auto(&A::g)); // expected-error {{functional-style cast to 'auto' has incompatible initializer of type '<overloaded function type>'}} + foo(auto(&A::g)); // expected-error {{functional-style cast to 'auto' has incompatible initializer of type '<overloaded function type>'}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} - foo(auto(a, 3.14)); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} - foo(auto{a, 3.14}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} - foo(auto({a, 3.14})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} - foo(auto{{a, 3.14}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} - foo(auto({a}, {3.14})); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} - foo(auto{{a}, {3.14}}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} + foo(auto(a, 3.14)); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{a, 3.14}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto({a, 3.14})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{{a, 3.14}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto({a}, {3.14})); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{{a}, {3.14}}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} - foo(auto{1, 2}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} - foo(auto({1, 2})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} - foo(auto{{1, 2}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} + foo(auto{1, 2}); // expected-error {{initializer for functional-style cast to 'auto' contains multiple expressions}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto({1, 2})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} + foo(auto{{1, 2}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}}s } diff --git a/clang/test/Lexer/cxx-features.cpp b/clang/test/Lexer/cxx-features.cpp index 171ef99cee5b7..9e67240ee8491 100644 --- a/clang/test/Lexer/cxx-features.cpp +++ b/clang/test/Lexer/cxx-features.cpp @@ -60,7 +60,7 @@ // --- C++23 features --- -#if check(auto_cast, 0, 0, 0, 0, 0, 202110, 202110) +#if check(auto_cast, 202110, 202110, 202110, 202110, 202110, 202110, 202110) #error "wrong value for __cpp_auto_cast" #endif diff --git a/clang/test/Parser/cxx1z-decomposition.cpp b/clang/test/Parser/cxx1z-decomposition.cpp index 21c9419e8f413..c075fa3c8128e 100644 --- a/clang/test/Parser/cxx1z-decomposition.cpp +++ b/clang/test/Parser/cxx1z-decomposition.cpp @@ -105,9 +105,8 @@ namespace BadSpecifiers { // defining-type-specifiers other than cv-qualifiers and 'auto' S [a] = s; // expected-error {{cannot be declared with type 'S'}} decltype(auto) [b] = s; // expected-error {{cannot be declared with type 'decltype(auto)'}} - auto ([c2]) = s; // cxx17-error {{structured binding declaration cannot be declared with parenthese}} \ - // post2b-error {{use of undeclared identifier 'c2'}} \ - // post2b-error {{expected body of lambda expression}} \ + auto ([c2]) = s; // expected-error {{use of undeclared identifier 'c2'}} \ + // expected-error {{expected body of lambda expression}} // FIXME: This error is not very good. auto [d]() = s; // expected-error {{expected ';'}} expected-error {{expected expression}} diff --git a/clang/test/Parser/cxx2b-auto-x.cpp b/clang/test/Parser/cxx2b-auto-x.cpp index 9e0277eee76a9..fed80ace7db85 100644 --- a/clang/test/Parser/cxx2b-auto-x.cpp +++ b/clang/test/Parser/cxx2b-auto-x.cpp @@ -2,14 +2,15 @@ // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s void looks_like_decltype_auto() { - decltype(auto(42)) b = 42; // cxx20-error {{'auto' not allowed here}} \ + decltype(auto(42)) b = 42; // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} \ cxx23-warning {{'auto' as a functional-style cast is incompatible with C++ standards before C++23}} decltype(long *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \ expected-error {{expected expression}} decltype(auto *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \ expected-error {{expected expression}} - decltype(auto()) c = 42; // cxx23-error {{initializer for functional-style cast to 'auto' is empty}} \ - cxx20-error {{'auto' not allowed here}} + decltype(auto()) c = 42; // expected-error {{initializer for functional-style cast to 'auto' is empty}} \ + cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} \ + cxx23-warning {{'auto' as a functional-style cast is incompatible with C++ standards before C++23}} } struct looks_like_declaration { @@ -19,11 +20,9 @@ struct looks_like_declaration { using T = looks_like_declaration *; void f() { T(&a)->n = 1; } void g() { auto(&a)->n = 0; } // cxx23-warning {{before C++23}} \ - // cxx20-error {{declaration of variable 'a' with deduced type 'auto (&)' requires an initializer}} \ - // cxx20-error {{expected ';' at end of declaration}} + // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} void h() { auto{&a}->n = 0; } // cxx23-warning {{before C++23}} \ - // cxx20-error {{expected unqualified-id}} \ - // cxx20-error {{expected expression}} + // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} void e(auto (*p)(int y) -> decltype(y)) {} @@ -36,19 +35,15 @@ struct S{ } s; // expected-note {{here}} void test() { - auto(s)()->N; // cxx23-warning {{expression result unused}} \ + auto(s)()->N; // expected-warning {{expression result unused}} \ // cxx23-warning {{before C++23}} \ - // cxx20-error {{unknown type name 'N'}} + // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} auto(s)()->M; // expected-error {{redefinition of 's' as different kind of symbol}} } void test_paren() { int a = (auto(0)); // cxx23-warning {{before C++23}} \ - // cxx20-error {{expected expression}} \ - // cxx20-error {{expected ')'}} \ - // cxx20-note {{to match this '('}} + // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} int b = (auto{0}); // cxx23-warning {{before C++23}} \ - // cxx20-error {{expected expression}} \ - // cxx20-error {{expected ')'}} \ - // cxx20-note {{to match this '('}} + // cxx20-warning {{'auto' as a functional-style cast is a C++23 extension}} } >From 9a89414e68a4ccdcba20918ef0cab7c77b4a11cb Mon Sep 17 00:00:00 2001 From: Nikolas Klauser <[email protected]> Date: Wed, 3 Jun 2026 09:41:13 +0200 Subject: [PATCH 2/5] Address comments --- clang/docs/ReleaseNotes.rst | 13 +++++++------ clang/test/Parser/cxx1z-decomposition.cpp | 2 ++ 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index fc0a1d2d4c926..8056365fcc9a7 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -191,6 +191,7 @@ C++ Language Changes -------------------- - ``__is_trivially_equality_comparable`` no longer returns false for all enum types. (#GH132672) +- ``auto()`` casts are accepted as an extension pre-C++23 C++2c Feature Support ^^^^^^^^^^^^^^^^^^^^^ @@ -363,7 +364,7 @@ Modified Compiler Flags - The `-mno-outline` flag will now add the `nooutline` IR attribute, so that `-mno-outline` and `-moutline` objects can be mixed correctly during LTO. -- Slightly changed hash id generation to get the unique linkage symbols names +- Slightly changed hash id generation to get the unique linkage symbols names by ``-unique-internal-linkage-names`` option. Now it uses a path that normalized in favor of the target system (same as the preprocessor does for the file macros) and allows the reproducable IDs on any build system. @@ -414,7 +415,7 @@ Attribute Changes in Clang - The ``[[clang::unsafe_buffer_usage]]`` attribute is now supported in API notes. For example: - + .. code-block:: yaml Functions: @@ -866,10 +867,10 @@ clang-format ------------ - Add ``ObjCSpaceAfterMethodDeclarationPrefix`` option to control space between the '-'/'+' and the return type in Objective-C method declarations -- Deprecate the ``BinPackParameters`` and ``BinPackArguments`` options and replace - them with the ``PackParameters`` and ``PackArguments`` structs (respectively) to - unify packing behavior. Add the ``BreakAfter`` option to the structs, allowing - parameter and argument lists to be formatted with one parameter/argument on each +- Deprecate the ``BinPackParameters`` and ``BinPackArguments`` options and replace + them with the ``PackParameters`` and ``PackArguments`` structs (respectively) to + unify packing behavior. Add the ``BreakAfter`` option to the structs, allowing + parameter and argument lists to be formatted with one parameter/argument on each line if they exceed the specified count. - Add ``AfterComma`` value to ``BreakConstructorInitializers`` to allow breaking constructor initializers after commas, keeping the colon on the same line. diff --git a/clang/test/Parser/cxx1z-decomposition.cpp b/clang/test/Parser/cxx1z-decomposition.cpp index c075fa3c8128e..7927748840b18 100644 --- a/clang/test/Parser/cxx1z-decomposition.cpp +++ b/clang/test/Parser/cxx1z-decomposition.cpp @@ -105,6 +105,8 @@ namespace BadSpecifiers { // defining-type-specifiers other than cv-qualifiers and 'auto' S [a] = s; // expected-error {{cannot be declared with type 'S'}} decltype(auto) [b] = s; // expected-error {{cannot be declared with type 'decltype(auto)'}} + + // FIXME: This diagnostic could be improved. auto ([c2]) = s; // expected-error {{use of undeclared identifier 'c2'}} \ // expected-error {{expected body of lambda expression}} >From d5876d33f0ac423b077e9d3d89d8f168790ff118 Mon Sep 17 00:00:00 2001 From: Nikolas Klauser <[email protected]> Date: Wed, 10 Jun 2026 13:05:40 +0200 Subject: [PATCH 3/5] Add trailing whitespace --- clang/docs/ReleaseNotes.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 2b6dffd02e082..b536088bce1dd 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -387,7 +387,7 @@ New Compiler Flags clang's ``-ffile-prefix-map=value`` and has known differences in behaviour with the CL's option that do not affect the functionality: nomalizes the macro prefix map pathes -- removes `./` and uses the target's platform- - specific path separator character when expanding the preprocessor macros -- + specific path separator character when expanding the preprocessor macros -- ``-ffile-reproducible`` (but not the debug and coverage prefix maps); does not require ``/experimental:deterministic`` as by MSVC. It needed for removing a hostname from a mangling hash gen, but clang-cl does not use @@ -761,7 +761,7 @@ Bug Fixes to C++ Support - We no longer consider conversion operators when copy-initializing from the same type. This was non conforming and could lead to recursive constraint satisfaction checking. (#GH149443) - Fixed a crash in Itanium C++ name mangling for a lambda in a local class field initializer inside a constructor/destructor. (#GH176395) -- Fixed a crash when Expr::ClassifyImpl computes a classification like CL_LValue or CL_PRValue, then asserts that this +- Fixed a crash when Expr::ClassifyImpl computes a classification like CL_LValue or CL_PRValue, then asserts that this agrees with the AST node's own value category. (#GH202693) - Fixed crashes in Itanium C++ name mangling for lambdas with trailing requires-clauses involving requires-expressions. (#GH100774) (#GH123854) - Fixed an invalid rejection and assertion failure while generating ``operator=`` for fields with the ``__restrict`` qualifier. (#GH37979) >From 9bacfcd3f7f337f51f49a6deee8438e64396299f Mon Sep 17 00:00:00 2001 From: Nikolas Klauser <[email protected]> Date: Mon, 15 Jun 2026 09:06:56 +0200 Subject: [PATCH 4/5] Address comments --- clang/docs/ReleaseNotes.rst | 2 +- clang/lib/Sema/SemaType.cpp | 4 ---- 2 files changed, 1 insertion(+), 5 deletions(-) diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index b536088bce1dd..86f7d864be9cb 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -191,7 +191,7 @@ C++ Language Changes -------------------- - ``__is_trivially_equality_comparable`` no longer returns false for all enum types. (#GH132672) -- ``auto()`` casts are accepted as an extension pre-C++23 +- ``auto()`` casts are accepted as an extension pre-C++23. - ``auto`` parameters are now available in all C++ language modes as an extension. C++2c Feature Support diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index a86e4ae135e71..39d7c8b6620e2 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -3251,10 +3251,6 @@ static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, DeducedIsTrailingReturnType = true; } - SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc(); - if (D.getName().getKind() == UnqualifiedIdKind::IK_ConversionFunctionId) - AutoRange = D.getName().getSourceRange(); - // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context. if (Deduced) { AutoType *Auto = dyn_cast<AutoType>(Deduced); >From 9ce3fba0aad44077cde3f4bc9fb73f72bd5d9792 Mon Sep 17 00:00:00 2001 From: Nikolas Klauser <[email protected]> Date: Sun, 16 Aug 2026 11:00:23 +0200 Subject: [PATCH 5/5] Fix merge conflict --- clang/docs/ReleaseNotes.rst | 1086 ----------------------------------- 1 file changed, 1086 deletions(-) delete mode 100644 clang/docs/ReleaseNotes.rst diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst deleted file mode 100644 index 86f7d864be9cb..0000000000000 --- a/clang/docs/ReleaseNotes.rst +++ /dev/null @@ -1,1086 +0,0 @@ -.. If you want to modify sections/contents permanently, you should modify both - ReleaseNotes.rst and ReleaseNotesTemplate.txt. - -=========================================== -Clang |release| |ReleaseNotesTitle| -=========================================== - -.. contents:: - :local: - :depth: 2 - -Written by the `LLVM Team <https://llvm.org/>`_ - -.. only:: PreRelease - - .. warning:: - These are in-progress notes for the upcoming Clang |version| release. - Release notes for previous releases can be found on - `the Releases Page <https://llvm.org/releases/>`_. - -Introduction -============ - -This document contains the release notes for the Clang C/C++/Objective-C -frontend, part of the LLVM Compiler Infrastructure, release |release|. Here we -describe the status of Clang in some detail, including major -improvements from the previous release and new feature work. For the -general LLVM release notes, see `the LLVM -documentation <https://llvm.org/docs/ReleaseNotes.html>`_. For the libc++ release notes, -see `this page <https://libcxx.llvm.org/ReleaseNotes.html>`_. All LLVM releases -may be downloaded from the `LLVM releases web site <https://llvm.org/releases/>`_. - -For more information about Clang or LLVM, including information about the -latest release, please see the `Clang Web Site <https://clang.llvm.org>`_ or the -`LLVM Web Site <https://llvm.org>`_. - -Potentially Breaking Changes -============================ - -C/C++ Language Potentially Breaking Changes -------------------------------------------- - -- Clang now makes it ill-formed to try to ``break`` out of or ``continue`` a loop inside its own condition, - increment, or init-statement in all C and C++ language modes. This means that code such as - - .. code-block:: c++ - - while (({ break; })) {} - - is now ill-formed. An outer loop can still be broken out of or continued so long as the inner loop is - in the body of the outer loop: - - .. code-block:: c++ - - // Ok, this breaks out of the 'for' loop. - for (;;) { - while (({ break; true; })) {} - } - - // Error: can't break out of the 'for' loop from within its own increment. - for (;;({ while (({ break; true; })) {} })) {} - - This also resolves a divergence from GCC: in a construct such as - - .. code-block:: c++ - - for (;;) { - while (({ break; true; })) {} - } - - Clang would previously ``break`` out of the ``while`` loop, whereas GCC (since version 9) would - ``break`` out of the ``for`` loop here. Now, Clang and GCC both break out of the ``for`` loop. - -C++ Specific Potentially Breaking Changes ------------------------------------------ - -- Clang now more aggressively optimizes away stores to objects after they are - dead. This behavior can be disabled with ``-fno-lifetime-dse``. - -- Clang now correctly rejects ``export`` declarations in module implementation - partitions. (#GH107602) - -- Template argument deduction now treats the ``N`` in ``_BitInt(N)`` - as being of type ``std::size_t`` instead of ``int``, - matching the deduction of array sizes from ``int(&)[N]``. - This is a breaking change for code that depended on the previously deduced type. (#GH195033) - -- Clang now rejects nested local classes defined in a different - block scope than their parent class. (#GH193472) - -ABI Changes in This Version ---------------------------- - -- Fixed incorrect struct layout for ``_BitInt`` bitfields wider than 255 bits - on MSVC targets. Internal bitfield tracking fields were changed from - ``unsigned char`` to ``uint64_t`` to prevent overflow. This might be an ABI - break for such structs compared to earlier Clang versions. -- Fixed a number of issues with the ``__regcall`` calling convention for passing - structs on non-Windows x86-64 targets, including a crash when handling empty - struct arguments. This changes how structs that contain arrays, floating point - types, or ``_Complex float`` types are passed, and may introduce - incompatibilities with code compiled by earlier versions of Clang that uses - the ``__regcall`` calling convention on these targets. (#GH62999) (#GH98635) -- Fixed Itanium mangling for lambdas in instantiated non-static data member - initializers by preserving the field-name closure-prefix. This changes the - mangled names for affected lambdas. (#GH190555) -- Clang now uses MSVC-compatible manglings for supported AArch64 SVE builtin - types when targeting the Microsoft ABI. This changes symbol names for - affected declarations compared to previous Clang releases. (#GH196170) -- The resume and destroy functions of C++20 coroutines now use the platform C - calling convention instead of LLVM's internal ``fastcc``. This makes the - coroutine ABI stable across LLVM versions and interoperable with other - compilers. On most targets this is not a breaking change because ``fastcc`` - and the platform C calling convention agree for ``void(ptr)``. It is an ABI - break on i686, MIPS O32, PowerPC64 ELFv1, and Lanai. - -AST Dumping Potentially Breaking Changes ----------------------------------------- - -- The JSON AST dump now includes all fields from ``AvailabilityAttr``: ``platform``, - ``introduced``, ``deprecated``, ``obsoleted``, ``unavailable``, ``message``, - ``strict``, ``replacement``, ``priority``, and ``environment``. Previously, these - fields were missing from the JSON output. -- Colons that appear at the end of a ParamCommentCommand name are not serialized - as part of the name. - -Clang Frontend Potentially Breaking Changes -------------------------------------------- - -- HIPSPV toolchain: `--offload-targets=spirv{32,64}` option is - deprecated and will be removed when the new offload driver becomes - default. The replacement for the option is - `--offload-targets=spirv{32,64}-unknown-chipstar` when using the new - offload driver (`--offload-new-driver`). -- The new driver (`--offload-new-driver`) is now default for all offloading - compilations. This changes the ABI for relocatable device code. Currently, - libraries will need to be recompiled, or used with - (`--no-offload-new-driver`). This option will be removed in the next release. - -- Clang no longer defines the ``__cpp_impl_coroutine`` feature test macro under the 32-bit x86 Microsoft ABI, - as support for coroutines on this target is incomplete. - When using coroutines on this target a warning is emmitted to indicate the lack of full support. - That warning can be disabled with ``-Wno-coroutines-unsupported-target``. (see #GH59382) - -Clang Python Bindings Potentially Breaking Changes --------------------------------------------------- -- Remove ``CompletionString.Availability``. No libclang interfaces returned instances of it. -- ``CompletionString.availability`` now returns instances of ``CompletionString.AvailabilityKindCompat``. - - Instances of ``AvailabilityKindCompat`` have the same ``__str__`` representation - as the previous ``CompletionChunk.Kind`` and are equality-comparable with - the existing ``AvailabilityKind`` enum. It will be replaced by ``AvailabilityKind`` - in a future release. When this happens, the return type of ``CompletionString.availability`` - will change to ``AvailabilityKind``, so it is recommended to use ``AvailabilityKind`` - to compare with the return values of ``CompletionString.availability``. -- Remove ``availabilityKinds``. In this release, uses of ``availabilityKinds`` - need to be replaced by ``CompletionString.AvailabilityKind``. -- ``CompletionChunk.kind`` now returns instances of ``CompletionChunkKind``. - - Instances of ``CompletionChunkKind`` have the same ``__str__`` representation - as the previous ``CompletionChunk.Kind`` for compatibility. - These representations will be changed in a future release to match other enums. -- Remove ``completionChunkKindMap``. In this release, uses of ``completionChunkKindMap`` - need to be replaced by ``CompletionChunkKind``. -- Move ``SPELLING_CACHE`` into ``CompletionChunk`` and change it to use - ``CompletionChunkKind`` instances as keys, instead of the enum values. - An alias is kept in the form of a ``SPELLING_CACHE`` variable, but it only supports - ``__getitem__`` and ``__contains__``. It will be removed in a future release. - Please migrate to using ``CompletionChunk.SPELLING_CACHE`` instead. -- ``SourceLocation`` and ``SourceRange`` now use ``NotImplemented`` to delegate - equality checks (``__eq__``) to the other object they are compared with when - they are of different classes. They previously returned ``False`` when compared - with objects of other classes. -- ``TranslationUnit.get_tokens`` now throws an error if both the ``extent`` and - ``locations`` argument are passed. Previousy, ``locations`` took precedence. -- ``_CXUnsavedFile`` will be renamed to ``UnsavedFile`` for consistency. - ``UnsavedFile`` is already available to use and existing uses should - be adapted to refer to it instead. ``_CXUnsavedFile`` will be removed in a - future release. - -OpenCL Potentially Breaking Changes ------------------------------------ -- Clang now diagnoses zero-length arrays as errors in OpenCL. OpenCL C 3.0 - section 6.11.d states that "Variable length arrays and structures with - flexible (or unsized) arrays are not supported." - -What's New in Clang |release|? -============================== - -C++ Language Changes --------------------- - -- ``__is_trivially_equality_comparable`` no longer returns false for all enum types. (#GH132672) -- ``auto()`` casts are accepted as an extension pre-C++23. -- ``auto`` parameters are now available in all C++ language modes as an extension. - -C++2c Feature Support -^^^^^^^^^^^^^^^^^^^^^ - -- Clang now propagates ``constinit`` and ``constexpr`` in structured bindings with tuple-like initializers. - -C++23 Feature Support -^^^^^^^^^^^^^^^^^^^^^ - -- Partially implement Itanium mangling for pack indexing. Partially substituted packs are not yet supported. (#GH112003) - -C++20 Feature Support -^^^^^^^^^^^^^^^^^^^^^ - -- Clang now supports `P1857R3 <https://wg21.link/p1857r3>`_ Modules Dependency Discovery. (#GH54047) - -C++17 Feature Support -^^^^^^^^^^^^^^^^^^^^^ - -Resolutions to C++ Defect Reports -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- Implemented `CWG1780 Explicit instantiation/specialization of generic lambda - operator() <https://cplusplus.github.io/CWG/issues/1780.html>`_ - -- Clang now allows omitting ``typename`` before a template name in a - conversion operator, implementing `CWG2413 <https://wg21.link/cwg2413>`_. - -- Clang now uses non-reference types for structured bindings whose initializer - returns a prvalue. This resolves `CWG3135 <https://wg21.link/cwg3135>`_. - -C Language Changes ------------------- - -C2y Feature Support -^^^^^^^^^^^^^^^^^^^ - -- Implemented the type-specific C2y ``<stdbit.h>`` rotate functions with constexpr - evaluation support: - ``stdc_rotate_left_{uc,us,ui,ul,ull}`` and - ``stdc_rotate_right_{uc,us,ui,ul,ull}``. - -- Implemented C2y ``<stdbit.h>`` memory reversal functions: - ``__builtin_stdc_memreverse8`` / ``stdc_memreverse8`` (in-place byte - reversal of a byte array) and ``stdc_memreverse8u{8,16,32,64}`` (byte-swap - of an exact-width unsigned integer value, usable in constant expressions). - -C23 Feature Support -^^^^^^^^^^^^^^^^^^^ -- Clang now allows C23 ``constexpr`` struct member access through the dot operator in constant expressions. (#GH178349) -- Fixed a failing assertion when validating an invalid structure redefinition - with a member which uses an incomplete enumeration type. (#GH190227) -- Clang now supports the C23 ``wN`` and ``wfN`` length modifiers. (#GH116962) -- Clang now recognizes the C23 ``H``, ``D``, and ``DD`` length modifiers in - format strings and diagnoses their use because Clang does not yet support - the corresponding decimal floating-point types, ``_Decimal32``, ``_Decimal64``, and ``_Decimal128``. (#GH116962) - -Objective-C Language Changes ------------------------------ - -- Clang now emits Objective-C number, array, and dictionary literals as - compile-time constant data structures rather than runtime ``objc_msgSend`` - calls on targets whose runtime supports constant literal classes. The - feature can be disabled altogether with ``-fno-objc-constant-literals``, - or selectively per literal kind with ``-fno-constant-nsnumber-literals``, - ``-fno-constant-nsarray-literals``, and - ``-fno-constant-nsdictionary-literals``. - -Non-comprehensive list of changes in this release -------------------------------------------------- - -- Added support for floating point and pointer values in most ``__atomic_`` - builtins. - -- Added ``__builtin_stdc_rotate_left`` and ``__builtin_stdc_rotate_right`` - for bit rotation of unsigned integers including ``_BitInt`` types. Rotation - counts are normalized modulo the bit-width and support negative values. - Usable in constant expressions. Implicit conversion is supported for - class/struct types with conversion operators. -- Implemented the following C23 ``<stdbit.h>`` builtins with ``_BitInt`` - support and constexpr evaluation: - ``__builtin_stdc_leading_zeros``, ``__builtin_stdc_leading_ones``, - ``__builtin_stdc_trailing_zeros``, ``__builtin_stdc_trailing_ones``, - ``__builtin_stdc_first_leading_zero``, ``__builtin_stdc_first_leading_one``, - ``__builtin_stdc_first_trailing_zero``, ``__builtin_stdc_first_trailing_one``, - ``__builtin_stdc_count_zeros``, ``__builtin_stdc_count_ones``, - ``__builtin_stdc_has_single_bit``, ``__builtin_stdc_bit_width``, - ``__builtin_stdc_bit_floor``, and ``__builtin_stdc_bit_ceil``. - -- Implemented the type-specific C23 ``<stdbit.h>`` functions with constexpr - evaluation support: - ``stdc_leading_zeros_{uc,us,ui,ul,ull}``, - ``stdc_leading_ones_{uc,us,ui,ul,ull}``, - ``stdc_trailing_zeros_{uc,us,ui,ul,ull}``, - ``stdc_trailing_ones_{uc,us,ui,ul,ull}``, - ``stdc_first_leading_zero_{uc,us,ui,ul,ull}``, - ``stdc_first_leading_one_{uc,us,ui,ul,ull}``, - ``stdc_first_trailing_zero_{uc,us,ui,ul,ull}``, - ``stdc_first_trailing_one_{uc,us,ui,ul,ull}``, - ``stdc_count_zeros_{uc,us,ui,ul,ull}``, - ``stdc_count_ones_{uc,us,ui,ul,ull}``, - ``stdc_has_single_bit_{uc,us,ui,ul,ull}``, - ``stdc_bit_width_{uc,us,ui,ul,ull}``, - ``stdc_bit_floor_{uc,us,ui,ul,ull}``, and - ``stdc_bit_ceil_{uc,us,ui,ul,ull}``. - -- A new generic bit-reverse builtin function ``__builtin_bitreverseg`` that - extends bit-reversal support to all standard integers type, including - ``_BitInt`` - -- Added ``__builtin_elementwise_clmul`` for carry-less multiplication of - integers including ``_BitInt`` types. This includes constexpr evaluation - support. - -- Deprecated float types support from ``__builtin_elementwise_max`` and - ``__builtin_elementwise_min``. - -- Added header ``endian.h`` which contains byte order helpers specified in POSIX - -- Added #pragma loop licm(disable) for llvm.loop.licm.disable metadata - -- Added a new ``ExplicitInstantiationDecl`` AST node to represent explicit - template instantiations (e.g., ``template void foo<int>();`` or - ``extern template class S<int>;``). Previously, source location information - for explicit instantiation statements was discarded after parsing. The new - node preserves the full source range including the ``extern`` and ``template`` - keywords, qualifiers, template arguments as written, and the declared type, - enabling tools such as language servers and refactoring engines to accurately - map source locations back to explicit instantiation sites. - -- ``typeid`` on references and pointers of ``final`` types no longer emits a - vtable lookup at runtime. - -- Updated support for Unicode from 15.1 to 18.0. - -- Linux and Windows toolchains now support Clang multilibs using - ``-fmultilib-flag=``. - -- The SafeStack builtins ``__builtin___get_unsafe_stack_ptr``, - ``__builtin___get_unsafe_stack_bottom``, ``__builtin___get_unsafe_stack_top``, - and ``__builtin___get_unsafe_stack_start`` are now deprecated. Use the - corresponding functions from ``<sanitizer/safestack_interface.h>`` instead. - -New Compiler Flags ------------------- -- New option ``-fms-anonymous-structs`` / ``-fno-ms-anonymous-structs`` added - to enable or disable Microsoft's anonymous struct/union extension without - enabling other ``-fms-extensions`` features (#GH177607). -- New option ``--precompile-reduced-bmi`` allows build system to generate a - reduced BMI only for a C++20 importable module unit. Previously the users - can only generate the reduced BMI as a by-product, e.g, an object files or - a full BMI. - -- New ``-cc1`` option ``-fexperimental-overflow-behavior-types`` added to - enable parsing of the experimental ``overflow_behavior`` type attribute and - type specifiers. - -- New ``-cl`` option ``/d2guardnochecks`` added to match MSVC. When Windows - Control Flow Guard (CFG) is enabled by other options, it will instruct Clang - to emit the CFG metadata, but disable adding checks. - -- New option ``-fdiagnostics-show-inlining-chain`` added to show inlining chain - notes for ``[[gnu::warning]]`` and ``[[gnu::error]]`` diagnostics. When a - function with these attributes is called from an inlined context, Clang can - now show which functions were inlined to reach the call. When debug info is - available (``-gline-directives-only`` (implicitly enabled at ``-g1``) or - higher), accurate source locations are used; otherwise, a heuristic fallback - is used with a note suggesting how to enable debug info for better accuracy. - -- New option ``-fwin-cfg-mechanism=`` added to control the mechanism used by - Control Flow Guard on Windows. Accepted values are ``automatic`` (default), - ``dispatch``, and ``check``. The ``dispatch`` mechanism uses the dispatch - function to perform indirect call checks and can improve performance, while - ``check`` uses the traditional check mechanism. -- New ``-cl`` option ``/d2guardcfgdispatch`` added to match MSVC. This acts as a - shorthand for ``-fwin-cfg-mechanism=dispatch``. -- New ``-cl`` option ``/d2guardcfgdispatch-`` added to match MSVC. This acts as a - shorthand for ``-fwin-cfg-mechanism=check``. - -- New option ``-f[no-]strict-bool`` added to control whether Clang can assume - that ``bool`` values loaded from memory cannot have a bit pattern other - than 0 or 1. - -- New option ``-fcrash-diagnostics-tar`` added to create an archive of crash - reproducer files for easier bug filing. - -- There are a new pair of flags for riscv32 called ``-mzilsd-word-align`` and - ``-mzilsd-strict-align`` which control whether Zilsd accesses are allowed to - be aligned to 4-byte alignment rather than fully unaligned or fully (8-byte) - aligned. - -- New ``-cl`` option ``/pathmap:`` added to match MSVC. This option acts as a - clang's ``-ffile-prefix-map=value`` and has known differences in behaviour - with the CL's option that do not affect the functionality: nomalizes the - macro prefix map pathes -- removes `./` and uses the target's platform- - specific path separator character when expanding the preprocessor macros -- - ``-ffile-reproducible`` (but not the debug and coverage prefix maps); - does not require ``/experimental:deterministic`` as by MSVC. It needed for - removing a hostname from a mangling hash gen, but clang-cl does not use - a hostname when generates the hashes. Known issues -- does not remap the - source file pathes within PCH/PCM files. - -Deprecated Compiler Flags -------------------------- - -Modified Compiler Flags ------------------------ -- The `-mno-outline` and `-moutline` compiler flags are now allowed on RISC-V and X86, which both support the machine outliner. -- The `-mno-outline` flag will now add the `nooutline` IR attribute, so that - `-mno-outline` and `-moutline` objects can be mixed correctly during LTO. - -- Slightly changed hash id generation to get the unique linkage symbols names - by ``-unique-internal-linkage-names`` option. Now it uses a path that - normalized in favor of the target system (same as the preprocessor does - for the file macros) and allows the reproducable IDs on any build system. - -Removed Compiler Flags ----------------------- - -Attribute Changes in Clang --------------------------- - -- Added new attribute ``stack_protector_ignore`` to opt specific local variables out of - the analysis which determines if a function should get a stack protector. A function - will still generate a stack protector if other local variables or command line flags - require it. - -- Added a new attribute, ``[[clang::no_outline]]`` to suppress outlining from - annotated functions. This uses the LLVM `nooutline` attribute. - -- Introduced a new type attribute ``__attribute__((overflow_behavior))`` which - currently accepts either ``wrap`` or ``trap`` as an argument, enabling - type-level control over overflow behavior. There is also an accompanying type - specifier for each behavior kind via `__ob_wrap` and `__ob_trap`. - -- Introduced a new function attribute ``__attribute__((__personality__(...)))`` - to explicitly specify the personality routine for exception handling. THis is - meant to be a low level tool for language runtime authors to associate a - foreign language personality with a given function. Note that this does not - perform any ABI validation for the personality routine. - -- :doc:`ThreadSafetyAnalysis` attributes now correctly handle implicit member - accesses in C, and parameter attributes in C++. This improves diagnostic - precision and fixes false positives. - -- The :doc:`ThreadSafetyAnalysis` attributes ``guarded_by`` and - ``pt_guarded_by`` now accept multiple capability arguments with refined - access semantics: *writing* requires all listed capabilities to be held - exclusively, while *reading* requires at least one to be held. This is - sound because any writer must hold all capabilities, so holding any one - prevents concurrent writes. - -- :doc:`ThreadSafetyAnalysis` attributes like ``acquire_capability``, - ``release_capability``, ``requires_capability``, ``locks_excluded``, - ``try_acquire_capability``, and ``assert_capability`` can now be applied to - function pointer variables and fields. The analysis checks calls through - annotated function pointers the same way it checks direct function calls. - Only plain function pointers are supported; pointers-to-member functions, - blocks, or wrappers (e.g. ``std::function``) are not yet supported. - -- The ``[[clang::unsafe_buffer_usage]]`` attribute is now supported in API - notes. For example: - - .. code-block:: yaml - - Functions: - - Name: myUnsafeFunction - UnsafeBufferUsage: true - -- When using ``-Wunsafe-buffer-usage`` without - ``-fsafe-buffer-usage-suggestions``, warnings are now emitted only - once per source file. Pre-compiled code (such as PCH or module - headers) is no longer repeatedly analyzed, as it is analyzed during - its initial compilation. (Traditionally included headers are still - analyzed within each translation unit that includes them). This - behavior matches most of other ``-W`` diagnostics. - - When ``-fsafe-buffer-usage-suggestions`` is enabled, the behavior - remains the same as before: pre-compiled code is deserialized and - analyzed alongside the translation unit that uses it, because fix-it - suggestion analysis requires full visibility of the translation - unit. - -- Added support for ``[[msvc::forceinline]]`` for functions and - ``[[msvc::forceinline_calls]]`` for statements. Both are aliases to - ``[[clang::always_inline]]`` with additional checks to ensure that they - are only accepted in places where MSVC also does. - -- The AMDGPU ``amdgpu_num_sgpr`` and ``amdgpu_num_vgpr`` attributes are now - deprecated. Clang emits a ``-Wdeprecated-declarations`` warning when they - are used. Use ``amdgpu_waves_per_eu`` instead to control SGPR and VGPR - usage. - -- Clang now allows GNU attributes between a member declarator and bit-field width. (#GH184954) - -- The ``[[clang::noescape]]`` attribute now disallows deallocating memory - through the annotated parameter. This information is currently not exposed to - LLVM for optimization purposes, to prevent breaking existing adopters. It may - instead be used by warnings and static analyses to provide more information - about pointer lifetimes. It may be used to power optimizations in the future, - however there are no concrete plans to do so at the moment. - -Improvements to Clang's diagnostics ------------------------------------ -- Fixed bug in ``-Wdocumentation`` so that it correctly handles explicit - function template instantiations (#64087). - -- Fixed concept template parameters not being recognized in ``-Wdocumentation`` - when mentioned in tparam comments. (#GH64087) - -- ``-Wunused-but-set-variable`` now diagnoses file-scope variables with - internal linkage (``static`` storage class) that are assigned but never used. - This new coverage is added under the subgroup ``-Wunused-but-set-global``, - allowing it to be disabled independently with ``-Wno-unused-but-set-global``. - (#GH148361) - -- Added ``-Wlifetime-safety`` to enable lifetime safety analysis, - a CFG-based intra-procedural analysis that detects use-after-free and related - temporal safety bugs. See the - `RFC <https://discourse.llvm.org/t/rfc-intra-procedural-lifetime-analysis-in-clang/86291>`_ - for more details. By design, this warning is enabled in ``-Weverything``. To disable - the analysis, use ``-Wno-lifetime-safety`` or ``-fno-lifetime-safety``. - -- Added ``-Wlifetime-safety-suggestions`` to enable lifetime annotation suggestions. - This provides suggestions for function parameters that - should be marked ``[[clang::lifetimebound]]`` based on lifetime analysis. For - example, for the following function: - - .. code-block:: c++ - - int* p(int *in) { return in; } - - Clang will suggest: - - .. code-block:: c++ - - warning: parameter in intra-TU function should be marked [[clang::lifetimebound]] - int* p(int *in) { return in; } - ^~~~~~~ - [[clang::lifetimebound]] - note: param returned here - int* p(int *in) { return in; } - ^~ - -- Added ``-Wlifetime-safety-noescape`` to detect misuse of ``[[clang::noescape]]`` - annotation where the parameter escapes through return. For example: - - .. code-block:: c++ - - int* p(int *in [[clang::noescape]]) { return in; } - - Clang will warn: - - .. code-block:: c++ - - warning: parameter is marked [[clang::noescape]] but escapes - int* p(int *in [[clang::noescape]]) { return in; } - ^~~~~~~ - note: returned here - int* p(int *in [[clang::noescape]]) { return in; } - ^~ - -- Added ``-Wlifetime-safety-dangling-field`` to detect dangling field references - when stack memory escapes to class fields. This is part of ``-Wlifetime-safety`` - and detects cases where local variables or parameters are stored in fields but - outlive their scope. For example: - - .. code-block:: c++ - - struct DanglingView { - std::string_view view; - DanglingView(std::string s) : view(s) {} // warning: address of stack memory escapes to a field - }; - -- Improved ``-Wassign-enum`` performance by caching enum enumerator values. (#GH176454) - -- Fixed a false negative in ``-Warray-bounds`` where the warning was suppressed - when accessing a member function on a past-the-end array element. - (#GH179128) - -- Added a missing space to the FixIt for the ``implicit-int`` group of diagnostics and - made sure that only one such diagnostic and FixIt is emitted per declaration group. (#GH179354) - -- Fixed the Fix-It insertion point for ``expected ';' after alias declaration`` - when parsing alias declarations involving a token-split ``>>`` sequence - (for example, ``using A = X<int>>;``). (#GH184425) - -- Fixed incorrect ``implicitly deleted`` diagnostic for explicitly deleted - candidate function. (#GH185693) - -- The ``-Wloop-analysis`` warning has been extended to catch more cases of - variable modification inside lambda expressions (#GH132038). - -- Clang now emits ``-Wsizeof-pointer-memaccess`` when snprintf/vsnprintf use the sizeof - the destination buffer(dynamically allocated) in the len parameter(#GH162366) - -- Added ``-Wmodule-map-path-outside-directory`` (off by default) to warn on - header and umbrella directory paths that use ``..`` to refer outside the module - directory in module maps found via implicit search - (``-fimplicit-module-maps``). This does not affect module maps specified - explicitly via ``-fmodule-map-file=``. - -- Honour ``[[maybe_unused]]`` attribute on private fields. - ``-Wunused-private-field`` no longer emits a warning for annotated private - fields. - -- Improved ``-Wgnu-zero-variadic-macro-arguments`` to suggest using - ``__VA_OPT__`` if the current language version supports it(#GH188624) - -- Clang now emits an error when implicitly casting a complex type to a built-in vector type. (#GH186805) - -- Added ``-Wnonportable-include-path-separator`` (off by default) to catch - #include directives that use backslashes as a path separator. The warning - includes a FixIt to change all the backslashes to forward slashes, so that the - code can automatically be made portable to other host platforms that don't - support backslashes. - -- Clang now explains why template deduction fails for explicit template arguments. - -- No longer emitting a ``-Wpre-c2y-compat`` or extension diagnostic about use - of octal literals with a ``0o`` prefix, and no longer emitting a - ``-Wdeprecated-octal-literals`` diagnostic for use of octal literals without - a ``0o`` prefix, when the literal is expanded from a macro defined in a - system header. (#GH192389) - -- Improved error recovery for missing semicolons after class members. Clang now avoids - skipping subsequent valid declarations when their previous decl is missing semicolon. - -- Removed the body of lambdas from some diagnostic messages. - -- Fixed false positive host-device mismatch errors in discarded `if constexpr` branches for CUDA/HIP; - such calls are now correctly skipped. - -- Clang now errors when a function declaration aliases a variable or vice versa. (#GH195550) - -- Added ``-Wattribute-alias`` to diagnose type mismatches between an alias and its aliased function. (#GH195550) - -- The diagnostics around ``__block`` now explain why a variable cannot be marked ``__block``. (#GH197213) - -- Extended ``-Wnonportable-include-path`` to warn about trailing whitespace and dots in ``#include`` paths. (#GH190610) - -- Clang now emits error when attribute is missing closing ``]]`` followed by ``;;``. (#GH187223) - -- Clang now rejects inline asm constraints and clobbers that contain an - embedded null character, instead of silently truncating them. (#GH173900) - -- Diagnostics for the C++11 range-based for statement now report the correct - iterator type in notes for invalid iterator types. - -Improvements to Clang's time-trace ----------------------------------- - -Improvements to Coverage Mapping --------------------------------- - -- [MC/DC] Nested expressions are handled as individual MC/DC expressions. -- "Single byte coverage" now supports branch coverage and can be used - together with ``-fcoverage-mcdc``. -- Consteval member functions are no longer emitted in coverage mappings, - matching the existing behavior for free consteval functions. (#GH164448) - -Bug Fixes in This Version -------------------------- - -- Fixed atomic boolean compound assignment; the conversion back to atomic bool would be miscompiled. (#GH33210) -- Correctly handle default template argument when establishing subsumption. (#GH188640) -- Fixed a failed assertion in the preprocessor when ``__has_embed`` parameters are missing parentheses. (#GH175088) -- Fix lifetime extension of temporaries in for-range-initializers in templates. (#GH165182) -- Fixed a preprocessor crash in ``__has_cpp_attribute`` on incomplete scoped attributes. (#GH178098) -- Fixes an assertion failure when evaluating ``__underlying_type`` on enum redeclarations. (#GH177943) -- Fixed an assertion failure caused by nested macro expansion during header-name lexing (``__has_embed(__has_include)``). (#GH178635) -- Clang now outputs relative paths of embeds for dependency output. (#GH161950) -- Fix the result type of a binary operation where both operands are 'void' l-values. (#GH111300) -- Fixed an assertion failure when evaluating ``_Countof`` on invalid ``void``-typed operands. (#GH180893) -- Fixed an assertion failure in the serialized diagnostic printer when it is destroyed without calling ``finish()``. (#GH140433) -- Fixed an assertion failure caused by error recovery while extending a nested name specifier with results from ordinary lookup. (#GH181470) -- Fixed a crash when parsing ``#pragma clang attribute`` arguments for attributes that forbid arguments. (#GH182122) -- Fixed a bug in how Clang re-transforms expressions produced from substititions - from type aliases and concept specializations. (#GH191738) (#GH196375) -- Fixed a bug with multiple-include optimization (MIOpt) state not being preserved in some cases during lexing, which could suppress header-guard mismatch diagnostics and interfere with include-guard optimization. (#GH180155) -- Fixed a crash when normalizing constraints involving concept template parameters whose index coincided with non-concept template parameters in the same parameter mapping. -- Fixed a crash caused by accessing dependent diagnostics of a non-dependent context. -- Fixed a crash when substituting into a non-type template parameter that has a type containing an undeduced placeholder type. -- Fixed several crashes and improved diagnostics when a multidimensional subscript operator is applied to a built-in type. (#GH187800) -- Correctly diagnosing and no longer crashing when ``export module foo`` - (without a semicolon) are the final tokens in a module file. (#GH187771) -- Fixed a crash in duplicate attribute checking caused by comparing constant arguments with different integer signedness. (#GH188259) -- Clang now emits an error when returning an initializer list from a lambda - with an explicit return type of void. The diagnostic now correctly refers - to "lambda" instead of "block". (#GH188661) -- Fixed a crash on _BitInt(N) arrays where 129 ≤ N ≤ 192 due to incorrect array filler lowering. (#GH189643) -- Fixed the behavior in C23 of ``auto``, by emitting an error when an array type is specified for a ``char *``. (#GH162694) -- Fixed an issue where an assert was thrown instead of an error if no vulkan env was specified with ``--triple spirv``. (#GH189964) -- Fixed incorrect rejection of ``auto`` with reordered declaration specifiers in C23. (#GH164121) -- Fixed a bug where Clang fails to find instantiation of Decls in constraint checking. (#GH173086) -- Fixed a crash when assigning to an element of an ``ext_vector_type`` with ``bool`` element type. (#GH189260) -- Fixed a crash caused by declaring multiple ``ownership_returns`` attributes with mismatched or missing arguments. (#GH188733) -- Clang now emits an error for friend declarations of lambda members. (#GH26540) -- Fixed a crash caused by lambda capture handling in delayed default arguments. (#GH176534) -- Fixed a crash when parsing invalid ``static_assert`` declarations with string-literal messages (#GH187690). -- Fixed a potential stack-use-after-return issue in Clang when copy-initializing - an array via an element-at-a-time copy loop (#GH192026) -- Fixed an issue where certain designated initializers would be rejected for constexpr variables. (#GH193373) -- Fixed a crash when ``#embed`` is used with C++ modules (#GH195350) -- Fixed an issue where ``__typeof_unqual`` and ``__typeof_unqual__`` were rejected as a declaration specifier in block scope in C++. -- Fixed crash when checking for overflow for unary operator that can't overflow (#GH170072) -- Clang no longer handles a `" q-char-sequence "` header name as a string literal (#GH132643). -- Fixed an assertion when ``__attribute__((alloc_size))`` is used with an argument type wider than the target's pointer width. (#GH190445) - -Bug Fixes to Compiler Builtins -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- Fix a crash when passing an unresolved overload set to ``__builtin_classify_type``. (#GH175589) -- Fixed a crash when calling `__builtin_allow_sanitize_check` with no arguments. (#GH183927) -- ``__annotation`` is now diagnosed as unsupported on non-Windows/UEFI targets, fixing a - crash when using it with ``-fms-extensions`` on other platforms. (#GH184318) -- Fixed a compiler crash due to an unresolved overloaded function type when - calling ``__builtin_bit_cast``. (#GH200112) - -Bug Fixes to Attribute Support -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- Fixed a behavioral discrepancy between deleted functions and private members when checking the ``enable_if`` attribute. (#GH175895) -- Fixed ``init_priority`` attribute by delaying type checks until after the type is deduced. -- Fixed a crash when a ``section`` attribute or ``#pragma clang section`` caused a - section type conflict with a declaration whose name is not a simple identifier, - such as a lambda's call operator. (#GH192264) - -Bug Fixes to C++ Support -^^^^^^^^^^^^^^^^^^^^^^^^ -- Fixed a preprocessor assertion failure triggered when parsing an invalid template-id starting with ``::template operator``. (#GH186582) -- Fixed a crash when a function template is defined as a non-template friend with a global scope qualifier. (#GH185341) -- Clang now rejects constant template parameters with block pointer types, since these are not implemented anyway and would lead to crashes. (#GH189247) -- Fixed a crash on error recovery when dealing with invalid templates. (#GH183075) -- Fixed a crash when instantiating ``requires`` expressions involving substitution failures in C++ concepts. (#GH176402) -- Concepts appearing in the require-clause of a member function no longer have access to non-public members of that class, - or to a current class object. (#GH115838) (#GH194803) (#GH197067) -- We no longer caches invalid variable specializations. (#GH132592) -- Fixed an incorrect template argument deduction when matching packs of template - template parameters when one of its parameters is also a pack. (#GH181166) -- Clang no longer errors on overloads with different ref-qualifiers and constraints. (#GH120812) -- Fixed a crash when a default argument is passed to an explicit object parameter. (#GH176639) -- Fixed an alias template CTAD crash. -- Correctly diagnose uses of ``co_await`` / ``co_yield`` in the default argument of nested function declarations. (#GH98923) -- Fixed a crash when diagnosing an invalid static member function with an explicit object parameter (#GH177741) -- Fixed clang incorrectly rejecting several cases of out-of-line definitions. (#GH101330) -- Clang incorrectly instantiated variable specializations outside of the immediate context. (#GH54439) -- Fixed a crash when pack expansions are used as arguments for non-pack parameters of built-in templates. (#GH180307) -- Fixed crash instantiating class member specializations. -- Fix a problem where a substitution failure when evaluating a type requirement - could directly make the program ill-formed. -- Fix a problem where pack index expressions where incorrectly being regarded as equivalent. -- Fixed a bug where captured variables in non-mutable lambdas were incorrectly treated as mutable - when used inside decltype in the return type. (#GH180460) -- Fixed a crash when evaluating uninitialized GCC vector/ext_vector_type vectors in ``constexpr``. (#GH180044) -- Fixed a crash when `explicit(bool)` is used with an incomplete enumeration. (#GH183887) -- Fixed a crash on ``typeid`` of incomplete local types during template instantiation. (#GH63242), (#GH176397) -- Fixed spurious diagnostics produced when checking if constraints are equivalent for redeclarations, - which could make the program mistakenly ill-formed. -- Fixed a crash when an immediate-invoked ``consteval`` lambda is used as an invalid initializer. (#GH185270) -- Fixed an assertion failure when using a global destructor with a target with a non-default program address space. (#GH186484) -- Fixed a crash when instantiating an invalid out-of-line static data member definition in a local class. (#GH176152) -- Inherited constructors in ``dllexport`` classes are now exported for ABI-compatible cases, matching - MSVC behavior. Constructors with variadic arguments or callee-cleanup parameters are not yet supported - and produce a warning. (#GH162640) -- Correctly diagnose invalid non-dependent calls in dependent contexts. (#GH135694) -- Fix initialization of GRO when GRO-return type mismatches, as part of CWG2563. (#GH98744) -- Fix an error using an initializer list with array new for a type that is not default-constructible. (#GH81157) -- We no longer consider conversion operators when copy-initializing from the same type. This was non - conforming and could lead to recursive constraint satisfaction checking. (#GH149443) -- Fixed a crash in Itanium C++ name mangling for a lambda in a local class field initializer inside a constructor/destructor. (#GH176395) -- Fixed a crash when Expr::ClassifyImpl computes a classification like CL_LValue or CL_PRValue, then asserts that this - agrees with the AST node's own value category. (#GH202693) -- Fixed crashes in Itanium C++ name mangling for lambdas with trailing requires-clauses involving requires-expressions. (#GH100774) (#GH123854) -- Fixed an invalid rejection and assertion failure while generating ``operator=`` for fields with the ``__restrict`` qualifier. (#GH37979) -- Fixed a use-after-free bug when parsing default arguments containing lambdas in declarations with template-id declarators. (#GH196725) -- Fixed a crash in constant evaluation using placement new on an array which was later initialized. (#GH196450) -- Fixed an issue where Clang incorrectly accepted invalid unqualified uses of local nested class names outside their declaring scope. (#GH184622) -- Fixed a crash when parsing invalid friend declaration with storage-class specifier. (#GH186569) - -Bug Fixes to AST Handling -^^^^^^^^^^^^^^^^^^^^^^^^^ -- Fixed a bug where explicit nullability property attributes were not stored in AST nodes in Objective-C. (#GH179703) -- Fixed a bug where alias CTAD, or an invalid template template parameter, could create a template with an empty template - parameter list. This also adds asserts to prevent this from happening again. -- Fixed a crash when parsing Doxygen ``@param`` commands attached to invalid declarations or non-function entities. (#GH182737) -- Fixed the SourceLocation and SourceRange of reversed rewritten CXXOperatorCallExpr. (#GH192467) -- Fixed a assertion when ``__block`` is used on global variables in C mode. (#GH183974) -- Added missing AST nodes representing the ``decltype`` specifiers in destructor call to AST. - -Miscellaneous Bug Fixes -^^^^^^^^^^^^^^^^^^^^^^^ -- Fixed a crash whith the AST text dumper, when dumping a reference to a - decomposition with no bindinds. (#GH198842) -- Fixed the arguments of the format attribute on ``__builtin_os_log_format``. Previously, they were off by 1. - -Miscellaneous Clang Crashes Fixed -^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ - -- Fixed a crash when attempting to jump over initialization of a variable with variably modified type. (#GH175540) -- Fixed a crash when using loop hint with a value dependent argument inside a - generic lambda. (#GH172289) -- Fixed a crash in C++ overload resolution with ``_Atomic``-qualified argument types. (#GH170433) -- Fixed a crash related to missing source locations (#GH186655) -- Fixed a crash when casting a parenthesized unresolved template-id or array section. (#GH183505) -- Fixed a crash when initializing a ``constexpr`` pointer with a floating-point literal in C23. (#GH180313) -- Fixed a lack of diagnostic for substitution failures in base classes when using `std::void_t`-like types. -- Fixed a crash when emitting debug info for base classes with instantiation-dependent-only types (#GH193932) -- Fixed an assertion when diagnosing address-space qualified ``new``/``delete`` in language-defined address spaces such as OpenCL ``__local``. (#GH178319) -- Fixed an assertion failure in ObjC++ ARC when binding a rvalue reference to reference with different lifetimes (#GH178524) -- Fixed a crash when subscripting a vector type with large unsigned integer values. (#GH180563) -- Fixed a crash when attempting to diagnose incompatible conversions involving function types (#GH182534) -- Fixed a crash when evaluating ``__is_bitwise_cloneable`` on invalid record types. (#GH183707) -- Fixed an assertion failure when casting a function pointer with a target with a non-default program address space. (#GH186210) -- Fixed a crash when ``decltype(__builtin_FUNCTION())`` is used as a template type argument. (#GH167433) -- Fixed an assertion failure when parsing an invalid ``decltype`` specifier with missing parentheses or extra semicolons. (#GH188014) -- Fixed a crash when explicitly casting a complex type to or from an atomic complex type. (#GH172208) -- Fixed a crash when explicitly casting a scalar to an atomic complex. (#GH114885) -- Fixed an assertion failure when parsing an invalid out-of-line enum definition with template parameters. (#GH187909) -- Fixed an assertion failure on invalid template template parameter during typo correction. (#GH183983) -- Fixed an assertion failure in ``isAtEndOfMacroExpansion`` on macro expansions crossing the boundary of two fileIDs. (#GH115007), (#GH21755) -- Fixed an assertion failure when ``__builtin_dump_struct`` is used with an - immediate-escalated callable. (#GH192846) - -OpenACC Specific Changes ------------------------- - -Target Specific Changes ------------------------ - -AMDGPU Support -^^^^^^^^^^^^^^ -- Introduced a new target specific builtin ``__builtin_amdgcn_processor_is``, - a late / deferred query for the current target processor. -- Introduced a new target specific builtin ``__builtin_amdgcn_is_invocable``, - a late / deferred query for the availability of target specific builtins. -- Initial support for gfx1310 -- The ``amdgpu_num_sgpr`` and ``amdgpu_num_vgpr`` function attributes are now - deprecated. Using them produces a ``-Wdeprecated-declarations`` warning. Use - ``amdgpu_waves_per_eu`` instead. - -NVPTX Support -^^^^^^^^^^^^^^ - -X86 Support -^^^^^^^^^^^ -- ``march=znver6`` is now supported. - -Arm and AArch64 Support -^^^^^^^^^^^^^^^^^^^^^^^ - -Android Support -^^^^^^^^^^^^^^^ - -Windows Support -^^^^^^^^^^^^^^^ - -- Clang now defines the ``_MSVC_TRADITIONAL`` macro as ``1`` when emulating MSVC - 19.15 (Visual Studio 2017 version 15.8) and later. (#GH47114) -- ``-fmacro-prefix-map=`` (``-ffile-prefix-map=``) now affects an anonymous namespace hash generation - for the MSVC targets and allows deterministic symbol mangling for reproducible builds. - -- Added the ``-fwinx64-eh-unwind=`` flag to select the x64 Windows unwind info - version (``v1``, ``v2-best-effort``, ``v2-required``, or ``v3``). The legacy - ``-fwinx64-eh-unwindv2=`` flag is deprecated; it is still accepted and mapped - onto the new flag as follows: - - .. list-table:: - :header-rows: 1 - - * - Legacy ``-fwinx64-eh-unwindv2=`` - - New ``-fwinx64-eh-unwind=`` - * - ``disabled`` - - ``v1`` (default; no flag forwarded) - * - ``best-effort`` - - ``v2-best-effort`` - * - ``required`` - - ``v2-required`` - - The MSVC-compatible ``/d2epilogunwind`` and ``/d2epilogunwindrequirev2`` - options map to ``v2-best-effort`` and ``v2-required`` respectively. - -- When targeting Windows x64 with EGPR (`-mapx-features=egpr`), Clang now - automatically enables V3 unwind info (`-fwinx64-eh-unwind=v3`) if no - explicit unwind version was specified. - -LoongArch Support -^^^^^^^^^^^^^^^^^ - -- DWARF fission is now compatible with linker relaxations, allowing `-gsplit-dwarf` and `-mrelax` - to be used together when building for the LoongArch platform. - -RISC-V Support -^^^^^^^^^^^^^^ - -- Tenstorrent Ascalon D8 was renamed to Ascalon X. Use `tt-ascalon-x` with `-mcpu` or `-mtune`. -- Intrinsics were added for the 'Zvabd` (RISC-V Integer Vector Absolute Difference) extension. -- Intrinsics were added for the 'Zvzip` (Reordering Structured Data in Vector Registers) extension. -- A new ``-mtune`` syntax was added to support processor-specific tuning feature string - Currently this new syntax is gated by the ``-mexperimental-mtune-syntax`` flag. - - -CUDA/HIP Language Changes -^^^^^^^^^^^^^^^^^^^^^^^^^ - -- The new offloading driver is now the default for HIP. Use - `--no-oflfoad-new-driver` to return to the old behavior. - -CUDA Support -^^^^^^^^^^^^ - -- Fixed a bug where host-device ambiguities in CUDA/HIP when retrieving the - address of specializations of templated functions that have overloads for both - host and device. (#GH199299) - -AIX Support -^^^^^^^^^^^ - -- The driver default for the linker flag `-bcdtors` now defaults to `mbr` - (instead of `all`) which only extracts static init from archive members which - would otherwise be referenced. - (See https://www.ibm.com/docs/en/aix/7.2.0?topic=l-ld-command for details). -- The driver now uses ``-lcompiler_rt`` instead of ``-latomic``, and the compiler-rt - archive has been renamed from ``libatomic.a`` to ``libcompiler_rt.a`` to avoid conflicts - between the LLVM libatomic and the GNU libatomic from the AIX toolbox as they share - the same library name. - -NetBSD Support -^^^^^^^^^^^^^^ - -WebAssembly Support -^^^^^^^^^^^^^^^^^^^ - -- Fixed a crash when ``__funcref`` is applied to a non-function pointer type. - (#GH118233) - -AVR Support -^^^^^^^^^^^ - -SystemZ Support -^^^^^^^^^^^^^^^ - -- Add support for `#pragma export` for z/OS. This is a pragma used to export functions and variables - with external linkage from shared libraries. It provides compatibility with the IBM XL C/C++ - compiler. - -DWARF Support in Clang ----------------------- - -Floating Point Support in Clang -------------------------------- - -Fixed Point Support in Clang ----------------------------- - -AST Matchers ------------- -- Add ``functionTypeLoc`` matcher for matching ``FunctionTypeLoc``. -- Add missing support for ``TraversalKind`` in some ``addMatcher()`` overloads. - -clang-format ------------- -- Add ``ObjCSpaceAfterMethodDeclarationPrefix`` option to control space between the - '-'/'+' and the return type in Objective-C method declarations -- Deprecate the ``BinPackParameters`` and ``BinPackArguments`` options and replace - them with the ``PackParameters`` and ``PackArguments`` structs (respectively) to - unify packing behavior. Add the ``BreakAfter`` option to the structs, allowing - parameter and argument lists to be formatted with one parameter/argument on each - line if they exceed the specified count. -- Add ``AfterComma`` value to ``BreakConstructorInitializers`` to allow breaking - constructor initializers after commas, keeping the colon on the same line. -- Extend ``BreakBinaryOperations`` to accept a structured configuration with - per-operator break rules and minimum chain length gating via ``PerOperator``. -- Add ``AllowShortRecordOnASingleLine`` option and set it to ``EmptyAndAttached`` for LLVM style. -- Add ``BreakFunctionDeclarationParameters`` option to always break before function - declaration parameters. -- Add ``EnumAssignments`` option to ``AlignConsecutiveAssignments`` for aligning - enum assignments without affecting other assignments. -- Add ``BreakBeforeReturnType`` option to break before the function return - type. - -libclang --------- -- Visit constraints of `auto` type to properly visit concept usages (#GH166580) -- Visit switch initializer statements (https://bugs.kde.org/show_bug.cgi?id=415537#c2) -- Fix crash in clang_getBinaryOperatorKindSpelling and clang_getUnaryOperatorKindSpelling -- The clang_Module_getASTFile API is deprecated and now always returns nullptr -- The clang_Cursor_getCommentRange API will now return a comment range for macro definitions that have documentation comments. -- Added CXType_PredefinedSugar for __ptrdiff_t, __size_t, and - __signed_size_t types, which are no longer exposed as - CXType_Unexposed. - -Code Completion ---------------- - -- Fixed a crash in code completion when using a C-Style cast with a parenthesized - operand in Objective-C++ mode. (#GH180125) - -Static Analyzer ---------------- - -Crash and bug fixes -^^^^^^^^^^^^^^^^^^^ - -- Fixed ``security.VAList`` checker producing false positives when analyzing - C23 code where ``va_start`` expands to ``__builtin_c23_va_start``. - -.. comment: - This is for the Static Analyzer. - Using the caret `^^^` underlining for subsections: - - Crash and bug fixes - - New checkers and features - - Improvements - - Moved checkers - -.. _release-notes-sanitizers: - -Sanitizers ----------- -- UndefinedBehaviorSanitizer now supports ``__ubsan_default_suppressions``. - -Python Binding Changes ----------------------- -- Add deprecation warnings to ``CompletionChunk.isKind...`` methods. - These will be removed in a future release. Existing uses should be adapted - to directly compare equality of the ``CompletionChunk`` kind with - the corresponding ``CompletionChunkKind`` variant. - - Affected methods: ``isKindOptional``, ``isKindTypedText``, ``isKindPlaceHolder``, - ``isKindInformative`` and ``isKindResultType``. -- Add a deprecation warning to ``CodeCompletionResults.results``. - This property will become an implementation detail with changed behavior in a - future release and should not be used directly.. Existing uses of - ``CodeCompletionResults.results`` should be changed to directly use - ``CodeCompletionResults``: it nows supports ``__len__`` and ``__getitem__``, - so it can be used the same as ``CodeCompletionResults.results``. -- Added a new helper method ``get_clang_version`` to the class ``Config`` to - read the version string of the libclang in use. - -OpenMP Support --------------- -- Added support for ``transparent`` clause in task and taskloop directives. -- Added support for ``use_device_ptr`` clause to accept an optional - ``fallback`` modifier (``fb_nullify`` or ``fb_preserve``) with OpenMP >= 61. -- Added support for ``local`` clause with declare_target directive when - OpenMP >= 60. - -SYCL Support ------------- -- SYCL compilations now default to ``-std=c++17`` when no explicit language - standard is specified. Standards below C++17 are rejected with a diagnostic. - -- Clang now assumes default target for SYCL device compilation is 64-bit SPIR-V - and it now diagnoses if a non-supporting target is specified via command line. - (#GH167358) - -- The SYCL runtime shared library has been renamed from ``libsycl.so`` to - ``libLLVMSYCL.so`` to align with LLVM naming conventions. - -- SYCL header include paths are now added automatically for both host and - device compilations. - -- SYCL runtime library linking is now supported on Windows. When ``-fsycl`` is - specified, Clang automatically adds ``/MD`` if no explicit CRT flag is - present, links the appropriate debug (``LLVMSYCLd.lib``) or release - (``LLVMSYCL.lib``) library, and rejects static CRT flags (``/MT``, - ``/MTd``) with a diagnostic. Use ``-nolibsycl`` to suppress automatic - library linking. - -- Fixed ``-nolibsycl`` being silently ignored on Linux: the SYCL runtime - library was unconditionally added to the link line even when the flag was - passed. - -Improvements -^^^^^^^^^^^^ -- Improved substitution performance in concept checking. (#GH172266) - -- Clang now preserves the left-hand side of a binary expression (such as an - assignment or comparison) in a ``RecoveryExpr`` when the right-hand side fails - to parse. This improves IDE features like go-to-definition in ``clangd``. - -Additional Information -====================== - -A wide variety of additional information is available on the `Clang web -page <https://clang.llvm.org/>`_. The web page contains versions of the -API documentation which are up-to-date with the Git version of -the source code. You can access versions of these documents specific to -this release by going into the "``clang/docs/``" directory in the Clang -tree. - -If you have any questions or comments about Clang, please feel free to -contact us on the `Discourse forums (Clang Frontend category) -<https://discourse.llvm.org/c/clang/6>`_. _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
