Fix the over aggressive check on parameter pack from template

Fix some UT

Signed-off-by: acassagnes <acassagnes@bloomberg.net>

Author: zebullax

clang/lib/AST/ExprConstantMeta.cpp

@@ -1112,8 +1112,8 @@ static bool getParameterName(ParmVarDecl *PVD, std::string &Out) {
   // instantiation's, and pack-substituted parameters were already
   // filtered above.)
   if (FunctionDecl *Pattern = FD->getTemplateInstantiationPattern();
-      Pattern && llvm::none_of(Pattern->parameters(), [](const ParmVarDecl *P) {
-        return P->isParameterPack();
+      Pattern && llvm::none_of(Pattern->parameters(), [&](const ParmVarDecl *P) {
+        return P->isParameterPack() && P->getFunctionScopeIndex() <= ParamIdx;
       }))
     FD = Pattern;
 

libcxx/include/meta

@@ -2384,7 +2384,13 @@ consteval auto data_member_spec(info member_type,
   bool has_name = options.name.has_value();
   int alignment = options.alignment.value_or(0);
   int width = options.width.value_or(0);
+  // 'no_unique_address' is intentionally deprecated in favor of
+  // '.attributes = { ^^[[no_unique_address]] }', but is still honored here for
+  // backward compatibility; suppress the deprecation warning at this read site.
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
   bool no_unique_address = options.no_unique_address;
+#pragma clang diagnostic pop
 
   if (width) {
     if (alignment)

libcxx/test/std/experimental/reflection/p3385-function-attributes.pass.cpp

@@ -10,7 +10,7 @@
 
 // UNSUPPORTED: c++03 || c++11 || c++14 || c++17 || c++20
 // ADDITIONAL_COMPILE_FLAGS: -freflection
-// ADDITIONAL_COMPILE_FLAGS: -freflection-new-syntax
+// ADDITIONAL_COMPILE_FLAGS: -freflection-latest
 // ADDITIONAL_COMPILE_FLAGS: -fattribute-reflection
 
 // <experimental/reflection>

libcxx/test/std/experimental/reflection/param-name-consistency-instantiation.pass.cpp

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// ADDITIONAL_COMPILE_FLAGS: -freflection-latest -fparameter-reflection
+// ADDITIONAL_COMPILE_FLAGS: -freflection-latest -fparameter-reflection -Wno-unused-parameter -Wno-deprecated-declarations
 
 // <experimental/meta>
 
@@ -47,4 +47,40 @@ static_assert(!has_identifier(param0("f")));
 static_assert(has_identifier(param0("g")));
 static_assert(identifier_of(param0("g")) == "width");
 
+template <class T> struct P {
+    template <class... Args> void h(int value, Args... rest);
+};
+template <class T> template <class... Args>
+void P<T>::h(int val, Args... rest) {}
+
+template void P<int>::h<float>(int, float);
+
+// The non-pack parameter "value"/"val" is inconsistently named. The pack sits at
+// pattern index 1, i.e. AFTER the queried index 0, so the query still walks the
+// pattern's declaration chain and detects the inconsistency.
+static_assert(!has_identifier(parameters_of(^^P<int>::h<float>)[0]));
+
+// A named parameter positioned AFTER a function parameter pack. Instantiating
+// with TWO pack elements makes "tail" land at instantiation index 3, while it
+// sits at index 2 in the pattern (where the pack is a single parameter). Because
+// a pack precedes the queried index, the query cannot safely index the pattern's
+// shorter parameter list and falls back to the instantiation. This must neither
+// misindex nor crash -- getParamDecl(3) on the 3-parameter pattern would be
+// out-of-bounds.
+template <class T> struct Q {
+  template <class... Args> void k(int value, Args... rest, int tail);
+};
+template <class T> template <class... Args>
+void Q<T>::k(int val, Args... rest, int tail) {}
+
+template void Q<int>::k<float, double>(int, float, double, int);
+
+// Pre-pack parameter (index 0): inconsistent name, detected via the pattern.
+static_assert(!has_identifier(parameters_of(^^Q<int>::k<float, double>)[0]));
+
+// Trailing parameter after the pack (instantiation index 3, pattern index 2):
+// must not crash; reports its consistently-spelled name.
+static_assert(has_identifier(parameters_of(^^Q<int>::k<float, double>)[3]));
+static_assert(identifier_of(parameters_of(^^Q<int>::k<float, double>)[3]) == "tail");
+
 int main(int, char**) { return 0; }