merge main into amd-staging (#657)

Author: ronlieb

clang/docs/ReleaseNotes.rst

@@ -800,6 +800,7 @@ Bug Fixes to C++ Support
 - Diagnose unresolved overload sets in non-dependent compound requirements. (#GH51246) (#GH97753)
 - Fix a crash when extracting unavailable member type from alias in template deduction. (#GH165560)
 - Fix incorrect diagnostics for lambdas with init-captures inside braced initializers. (#GH163498)
+- Fixed spurious diagnoses of certain nested lambda expressions. (#GH149121) (#GH156579)
 
 Bug Fixes to AST Handling
 ^^^^^^^^^^^^^^^^^^^^^^^^^

clang/lib/Frontend/CompilerInvocation.cpp

@@ -856,10 +856,9 @@ static bool RoundTrip(ParseFn Parse, GenerateFn Generate,
   // Compares two lists of arguments.
   auto Equal = [](const ArrayRef<const char *> A,
                   const ArrayRef<const char *> B) {
-    return std::equal(A.begin(), A.end(), B.begin(), B.end(),
-                      [](const char *AElem, const char *BElem) {
-                        return StringRef(AElem) == StringRef(BElem);
-                      });
+    return llvm::equal(A, B, [](const char *AElem, const char *BElem) {
+      return StringRef(AElem) == StringRef(BElem);
+    });
   };
 
   // If we generated different arguments from what we assume are two

clang/lib/Lex/Preprocessor.cpp

@@ -1458,10 +1458,8 @@ void Preprocessor::removeCommentHandler(CommentHandler *Handler) {
 
 bool Preprocessor::HandleComment(Token &result, SourceRange Comment) {
   bool AnyPendingTokens = false;
-  for (std::vector<CommentHandler *>::iterator H = CommentHandlers.begin(),
-       HEnd = CommentHandlers.end();
-       H != HEnd; ++H) {
-    if ((*H)->HandleComment(*this, Comment))
+  for (CommentHandler *H : CommentHandlers) {
+    if (H->HandleComment(*this, Comment))
       AnyPendingTokens = true;
   }
   if (!AnyPendingTokens || getCommentRetentionState())

clang/lib/Sema/TreeTransform.h

@@ -15628,6 +15628,8 @@ TreeTransform<Derived>::TransformLambdaExpr(LambdaExpr *E) {
     DC = DC->getParent();
   if ((getSema().isUnevaluatedContext() ||
        getSema().isConstantEvaluatedContext()) &&
+      !(dyn_cast_or_null<CXXRecordDecl>(DC->getParent()) &&
+        cast<CXXRecordDecl>(DC->getParent())->isGenericLambda()) &&
       (DC->isFileContext() || !DC->getParent()->isDependentContext()))
     DependencyKind = CXXRecordDecl::LDK_NeverDependent;
 

clang/lib/StaticAnalyzer/Checkers/CallAndMessageChecker.cpp

@@ -322,13 +322,12 @@ bool CallAndMessageChecker::PreVisitProcessArg(
         else {
           os << " (e.g., via the field chain: '";
           bool first = true;
-          for (SmallVectorImpl<const FieldDecl *>::iterator
-               DI = F.FieldChain.begin(), DE = F.FieldChain.end(); DI!=DE;++DI){
+          for (const FieldDecl *FD : F.FieldChain) {
             if (first)
               first = false;
             else
               os << '.';
-            os << **DI;
+            os << *FD;
           }
           os << "')";
         }

clang/test/SemaCXX/cxx2a-consteval.cpp

@@ -1319,6 +1319,27 @@ namespace GH139160{
   B result = (B){10, get_value(make_struct())}; // expected-error {{initializer element is not a compile-time constant}} 
                                                 // expected-error@-1 {{call to consteval function 'GH139160::get_value' is not a constant expression}}
                                                 // expected-note@-2  {{non-constexpr function 'make_struct' cannot be used in a constant expression}}
-};
+}  // namespace GH139160
+
+namespace GH118187 {
+
+template <typename T> int t() {
+  return []<typename U>() consteval {
+    return [](U v) { return v; }(123);
+  }.template operator()<int>();
+}
 
+int v = t<int>();
+}  // namespace GH118187
 
+namespace GH156579 {
+template <class>
+auto f{[] (auto...) {
+    if constexpr ([] (auto) { return true; }(0))
+        return 0;
+}};
+
+void g() {
+    f<int>();
+}
+}  // namespace GH156579

clang/utils/TableGen/NeonEmitter.cpp

@@ -2233,13 +2233,10 @@ NeonEmitter::areRangeChecksCompatible(const ArrayRef<ImmCheck> ChecksA,
   // the same. The element types may differ as they will be resolved
   // per-intrinsic as overloaded types by SemaArm.cpp, though the vector sizes
   // are not and so must be the same.
-  bool compat =
-      std::equal(ChecksA.begin(), ChecksA.end(), ChecksB.begin(), ChecksB.end(),
-                 [](const auto &A, const auto &B) {
-                   return A.getImmArgIdx() == B.getImmArgIdx() &&
-                          A.getKind() == B.getKind() &&
-                          A.getVecSizeInBits() == B.getVecSizeInBits();
-                 });
+  bool compat = llvm::equal(ChecksA, ChecksB, [](const auto &A, const auto &B) {
+    return A.getImmArgIdx() == B.getImmArgIdx() && A.getKind() == B.getKind() &&
+           A.getVecSizeInBits() == B.getVecSizeInBits();
+  });
 
   return compat;
 }

flang/include/flang/Parser/openmp-utils.h

@@ -126,6 +126,17 @@ const OpenMPConstruct *GetOmp(const ExecutionPartConstruct &x);
 const OpenMPLoopConstruct *GetOmpLoop(const ExecutionPartConstruct &x);
 const DoConstruct *GetDoConstruct(const ExecutionPartConstruct &x);
 
+// Is the template argument "Statement<T>" for some T?
+template <typename T> struct IsStatement {
+  static constexpr bool value{false};
+};
+template <typename T> struct IsStatement<Statement<T>> {
+  static constexpr bool value{true};
+};
+
+std::optional<Label> GetStatementLabel(const ExecutionPartConstruct &x);
+std::optional<Label> GetFinalLabel(const OpenMPConstruct &x);
+
 const OmpObjectList *GetOmpObjectList(const OmpClause &clause);
 
 template <typename T>

flang/lib/Parser/openmp-parsers.cpp

@@ -71,7 +71,7 @@ template <typename ExecParser> struct AsBlockParser {
     if (auto &&exec{attempt(epc_).Parse(state)}) {
       Block body;
       body.push_back(std::move(*exec));
-      return body;
+      return std::move(body); // std::move for GCC 7.5.0
     }
     return std::nullopt;
   }
@@ -1731,30 +1731,6 @@ struct NonBlockDoConstructParser {
     }
     return std::nullopt;
   }
-
-private:
-  // Is the template argument "Statement<T>" for some T?
-  template <typename T> struct IsStatement {
-    static constexpr bool value{false};
-  };
-  template <typename T> struct IsStatement<Statement<T>> {
-    static constexpr bool value{true};
-  };
-
-  // Get the Label from a Statement<...> contained in an ExecutionPartConstruct,
-  // or std::nullopt, if there is no Statement<...> contained in there.
-  template <typename T>
-  static std::optional<Label> GetStatementLabel(const T &stmt) {
-    if constexpr (IsStatement<T>::value) {
-      return stmt.label;
-    } else if constexpr (WrapperTrait<T>) {
-      return GetStatementLabel(stmt.v);
-    } else if constexpr (UnionTrait<T>) {
-      return common::visit(
-          [&](auto &&s) { return GetStatementLabel(s); }, stmt.u);
-    }
-    return std::nullopt;
-  }
 };
 
 struct LoopNestParser {

flang/lib/Parser/openmp-utils.cpp

@@ -15,6 +15,7 @@
 #include "flang/Common/indirection.h"
 #include "flang/Common/template.h"
 #include "flang/Common/visit.h"
+#include "flang/Parser/tools.h"
 
 #include <tuple>
 #include <type_traits>
@@ -58,6 +59,63 @@ const DoConstruct *GetDoConstruct(const ExecutionPartConstruct &x) {
   return nullptr;
 }
 
+// Get the Label from a Statement<...> contained in an ExecutionPartConstruct,
+// or std::nullopt, if there is no Statement<...> contained in there.
+template <typename T>
+static std::optional<Label> GetStatementLabelHelper(const T &stmt) {
+  if constexpr (IsStatement<T>::value) {
+    return stmt.label;
+  } else if constexpr (WrapperTrait<T>) {
+    return GetStatementLabelHelper(stmt.v);
+  } else if constexpr (UnionTrait<T>) {
+    return common::visit(
+        [&](auto &&s) { return GetStatementLabelHelper(s); }, stmt.u);
+  }
+  return std::nullopt;
+}
+
+std::optional<Label> GetStatementLabel(const ExecutionPartConstruct &x) {
+  return GetStatementLabelHelper(x);
+}
+
+static std::optional<Label> GetFinalLabel(const Block &x) {
+  if (!x.empty()) {
+    const ExecutionPartConstruct &last{x.back()};
+    if (auto *omp{Unwrap<OpenMPConstruct>(last)}) {
+      return GetFinalLabel(*omp);
+    } else if (auto *doLoop{Unwrap<DoConstruct>(last)}) {
+      return GetFinalLabel(std::get<Block>(doLoop->t));
+    } else {
+      return GetStatementLabel(x.back());
+    }
+  } else {
+    return std::nullopt;
+  }
+}
+
+std::optional<Label> GetFinalLabel(const OpenMPConstruct &x) {
+  return common::visit(
+      [](auto &&s) -> std::optional<Label> {
+        using TypeS = llvm::remove_cvref_t<decltype(s)>;
+        if constexpr (std::is_same_v<TypeS, OpenMPSectionsConstruct>) {
+          auto &list{std::get<std::list<OpenMPConstruct>>(s.t)};
+          if (!list.empty()) {
+            return GetFinalLabel(list.back());
+          } else {
+            return std::nullopt;
+          }
+        } else if constexpr ( //
+            std::is_same_v<TypeS, OpenMPLoopConstruct> ||
+            std::is_same_v<TypeS, OpenMPSectionConstruct> ||
+            std::is_base_of_v<OmpBlockConstruct, TypeS>) {
+          return GetFinalLabel(std::get<Block>(s.t));
+        } else {
+          return std::nullopt;
+        }
+      },
+      x.u);
+}
+
 const OmpObjectList *GetOmpObjectList(const OmpClause &clause) {
   // Clauses with OmpObjectList as its data member
   using MemberObjectListClauses = std::tuple<OmpClause::Copyin,