[clang] Improve error recovery for pack expansion of expressions

[mizvekov]

Summary

Closes #58673.

Signed-off-by: Matheus Izvekov <[e-mail]>

clang/docs/ReleaseNotes.rst

- Clang now correctly points to the problematic parameter for the ``-Wnonnull``
   `Issue 58273 <https://github.com/llvm/llvm-project/issues/58273>`_.
 - Introduced ``-Wcast-function-type-strict`` to warn about function type mismatches
   in casts that may result in runtime indirect call `Control-Flow Integrity (CFI)
   <https://clang.llvm.org/docs/ControlFlowIntegrity.html>`_ failures. This diagnostic
   is grouped under ``-Wcast-function-type`` as it identifies a more strict set of
   potentially problematic function type casts.
 - Clang will now disambiguate NTTP types when printing diagnostic that contain NTTP types.
   Fixes `Issue 57562 <https://github.com/llvm/llvm-project/issues/57562>`_.
+- Better error recovery for pack expansion of expressions.
+  `Issue 58673 <https://github.com/llvm/llvm-project/issues/58673>`_.
 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - It's now possible to set the crash diagnostics directory through
   the environment variable ``CLANG_CRASH_DIAGNOSTICS_DIR``.
   The ``-fcrash-diagnostics-dir`` flag takes precedence.
 - When using header modules, inclusion of a private header and violations of
   the `use-declaration rules

clang/lib/AST/ComputeDependence.cpp

 
 ExprDependence clang::computeDependence(RecoveryExpr *E) {
   // RecoveryExpr is
   //   - always value-dependent, and therefore instantiation dependent
   //   - contains errors (ExprDependence::Error), by definition
   //   - type-dependent if we don't know the type (fallback to an opaque
   //     dependent type), or the type is known and dependent, or it has
   //     type-dependent subexpressions.
-  auto D = toExprDependenceForImpliedType(E->getType()->getDependence()) |
+  auto D = toExprDependenceAsWritten(E->getType()->getDependence()) |
            ExprDependence::ErrorDependent;
   // FIXME: remove the type-dependent bit from subexpressions, if the
   // RecoveryExpr has a non-dependent type.
   for (auto *S : E->subExpressions())
     D |= S->getDependence();
   return D;
 }
 

clang/test/CXX/temp/temp.decls/temp.variadic/p5.cpp

-// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fblocks -fms-extensions -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fblocks -fms-extensions -fsyntax-only -verify=expected,cxx11 %s
+// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++2b -fblocks -fms-extensions -fsyntax-only -verify=expected %s
 
 template<typename T, typename U> struct pair;
 template<typename ...> struct tuple;
 
 // A parameter pack whose name appears within the pattern of a pack
 // expansion is expanded by that pack expansion. An appearance of the
 // name of a parameter pack is only expanded by the innermost
 // enclosing pack expansion. The pattern of a pack expansion shall
struct TestUnexpandedTTP {
   typedef tuple<typename Meta<T>::type> type; // expected-error{{declaration type contains unexpanded parameter pack 'Meta'}}
 };
 
 // Test for unexpanded parameter packs in declarations.
 template<typename T, typename... Types>
 // FIXME: this should test that the diagnostic reads "type contains..."
 struct alignas(Types) TestUnexpandedDecls : T{ // expected-error{{expression contains unexpanded parameter pack 'Types'}}
   void member_function(Types);  // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
+#if __cplusplus < 201703L
   void member_function () throw(Types); // expected-error{{exception type contains unexpanded parameter pack 'Types'}}
+#endif
   void member_function2() noexcept(Types()); // expected-error{{expression contains unexpanded parameter pack 'Types'}}
   operator Types() const; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
   Types data_member;  // expected-error{{data member type contains unexpanded parameter pack 'Types'}}
   static Types static_data_member; // expected-error{{declaration type contains unexpanded parameter pack 'Types'}}
   unsigned bit_field : static_cast<Types>(0);  // expected-error{{bit-field size contains unexpanded parameter pack 'Types'}}
   static_assert(static_cast<Types>(0), "Boom"); // expected-error{{static assertion contains unexpanded parameter pack 'Types'}}
 
   enum E0 : Types {  // expected-error{{fixed underlying type contains unexpanded parameter pack 'Types'}}
namespace PR16303 {
   };
   B<1,2>::C<4,5,6> c1; // expected-note{{in instantiation of}}
   B<1,2,3,4>::C<4,5,6> c2; // expected-note{{in instantiation of}}
 }
 
 namespace PR21289 {
   template<int> using T = int;
   template<typename> struct S { static const int value = 0; };
-  template<typename> const int vt = 0; // expected-warning {{extension}}
+  template<typename> const int vt = 0; // cxx11-warning {{extension}}
   int f(...);
   template<int ...Ns> void g() {
     f(T<Ns>()...);
     f(S<T<Ns>>::value...);
     f(vt<T<Ns>>...);
   }
   template void g<>();
   template void g<1, 2, 3>();
template <bool... I> struct E {
   template <bool... U> using B = G<F<I, U>...>;
   // expected-error@-1 {{pack expansion contains parameter packs 'I' and 'U' that have different lengths (1 vs. 2)}}
   template <bool U1, bool U2> E(B<U1, U2> *);
   // expected-note@-1 {{in instantiation of template type alias 'B' requested here}}
 };
 using t2 = E<true>::B<false>;
 // expected-note@-1 {{in instantiation of template class 'pr56094::E<true>' requested here}}
 } // namespace pr56094
+
+namespace GH56094 {
+#if __cplusplus >= 201402L
+template <class> struct A; // expected-note {{template is declared here}}
+template <class> using B = char;
+template <class ...Cs> int C{ A<B<Cs>>{}... }; // expected-error {{implicit instantiation of undefined template}}
+#endif
+} // namespace GH56094