Integrate LLVM at llvm/llvm-project@2d287f51eff2

Updates LLVM usage to match
[2d287f51eff2](llvm/llvm-project@2d287f51eff2)

PiperOrigin-RevId: 756508479

Author: alinas

dependency_support/llvm/llvm.patch

@@ -1,12 +1,154 @@
 Auto generated patch. Do not edit or delete it, even if empty.
-diff -ruN --strip-trailing-cr a/lldb/unittests/Core/MangledTest.cpp b/lldb/unittests/Core/MangledTest.cpp
---- a/lldb/unittests/Core/MangledTest.cpp
-+++ b/lldb/unittests/Core/MangledTest.cpp
-@@ -605,6 +605,7 @@
-   EXPECT_EQ(get_part(OB.NameInfo.BasenameRange), basename);
-   EXPECT_EQ(get_part(OB.NameInfo.ScopeRange), scope);
-   EXPECT_EQ(get_part(OB.NameInfo.QualifiersRange), qualifiers);
-+  std::free(OB.getBuffer());
+diff -ruN --strip-trailing-cr a/clang/include/clang/AST/Type.h b/clang/include/clang/AST/Type.h
+--- a/clang/include/clang/AST/Type.h
++++ b/clang/include/clang/AST/Type.h
+@@ -3602,6 +3602,9 @@
+   }
+ 
+   NestedNameSpecifier *getQualifier() const { return Qualifier; }
++  /// Note: this can trigger extra deserialization when external AST sources are
++  /// used. Prefer `getCXXRecordDecl()` unless you really need the most recent
++  /// decl.
+   CXXRecordDecl *getMostRecentCXXRecordDecl() const;
+ 
+   bool isSugared() const;
+@@ -3610,7 +3613,10 @@
+   }
+ 
+   void Profile(llvm::FoldingSetNodeID &ID) {
+-    Profile(ID, getPointeeType(), getQualifier(), getMostRecentCXXRecordDecl());
++    // FIXME: `getMostRecentCXXRecordDecl()` should be possible to use here,
++    // however when external AST sources are used it causes nondeterminism
++    // issues (see https://github.com/llvm/llvm-project/pull/137910).
++    Profile(ID, getPointeeType(), getQualifier(), getCXXRecordDecl());
+   }
+ 
+   static void Profile(llvm::FoldingSetNodeID &ID, QualType Pointee,
+@@ -3620,6 +3626,9 @@
+   static bool classof(const Type *T) {
+     return T->getTypeClass() == MemberPointer;
+   }
++
++private:
++  CXXRecordDecl *getCXXRecordDecl() const;
+ };
+ 
+ /// Capture whether this is a normal array (e.g. int X[4])
+diff -ruN --strip-trailing-cr a/clang/lib/AST/Type.cpp b/clang/lib/AST/Type.cpp
+--- a/clang/lib/AST/Type.cpp
++++ b/clang/lib/AST/Type.cpp
+@@ -5305,10 +5305,14 @@
+     ID.AddPointer(Cls->getCanonicalDecl());
+ }
+ 
++CXXRecordDecl *MemberPointerType::getCXXRecordDecl() const {
++  return dyn_cast<MemberPointerType>(getCanonicalTypeInternal())
++      ->getQualifier()
++      ->getAsRecordDecl();
++}
++
+ CXXRecordDecl *MemberPointerType::getMostRecentCXXRecordDecl() const {
+-  auto *RD = dyn_cast<MemberPointerType>(getCanonicalTypeInternal())
+-                 ->getQualifier()
+-                 ->getAsRecordDecl();
++  auto *RD = getCXXRecordDecl();
+   if (!RD)
+     return nullptr;
+   return RD->getMostRecentNonInjectedDecl();
+diff -ruN --strip-trailing-cr a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp
+--- a/clang/lib/Sema/SemaChecking.cpp
++++ b/clang/lib/Sema/SemaChecking.cpp
+@@ -11596,6 +11596,15 @@
+   }
  }
 
- INSTANTIATE_TEST_SUITE_P(DemanglingPartsTests, DemanglingPartsTestFixture,
++static void CheckCommaOperand(Sema &S, Expr *E, QualType T, SourceLocation CC,
++                              bool ExtraCheckForImplicitConversion) {
++  E = E->IgnoreParenImpCasts();
++  AnalyzeImplicitConversions(S, E, CC);
++
++  if (ExtraCheckForImplicitConversion && E->getType() != T)
++    S.CheckImplicitConversion(E, T, CC);
++}
++
+ /// Analyze the given compound assignment for the possible losing of
+ /// floating-point precision.
+ static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {
+@@ -12413,7 +12422,7 @@
+           << OrigE->getSourceRange() << T->isBooleanType()
+           << FixItHint::CreateReplacement(UO->getBeginLoc(), "!");
+ 
+-  if (const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))
++  if (auto *BO = dyn_cast<BinaryOperator>(SourceExpr)) {
+     if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) &&
+         BO->getLHS()->isKnownToHaveBooleanValue() &&
+         BO->getRHS()->isKnownToHaveBooleanValue() &&
+@@ -12439,7 +12448,21 @@
+                    (BO->getOpcode() == BO_And ? "&&" : "||"));
+         S.Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);
+       }
++    } else if (BO->isCommaOp() && !S.getLangOpts().CPlusPlus) {
++      /// Analyze the given comma operator. The basic idea behind the analysis
++      /// is to analyze the left and right operands slightly differently. The
++      /// left operand needs to check whether the operand itself has an implicit
++      /// conversion, but not whether the left operand induces an implicit
++      /// conversion for the entire comma expression itself. This is similar to
++      /// how CheckConditionalOperand behaves; it's as-if the correct operand
++      /// were directly used for the implicit conversion check.
++      CheckCommaOperand(S, BO->getLHS(), T, BO->getOperatorLoc(),
++                        /*ExtraCheckForImplicitConversion=*/false);
++      CheckCommaOperand(S, BO->getRHS(), T, BO->getOperatorLoc(),
++                        /*ExtraCheckForImplicitConversion=*/true);
++      return;
+     }
++  }
+ 
+   // For conditional operators, we analyze the arguments as if they
+   // were being fed directly into the output.
+diff -ruN --strip-trailing-cr a/clang/test/Sema/implicit-cast.c b/clang/test/Sema/implicit-cast.c
+--- a/clang/test/Sema/implicit-cast.c
++++ b/clang/test/Sema/implicit-cast.c
+@@ -1,4 +1,4 @@
+-// RUN: %clang_cc1 -fsyntax-only %s
++// RUN: %clang_cc1 -fsyntax-only -verify %s
+ 
+ static char *test1(int cf) {
+   return cf ? "abc" : 0;
+@@ -6,3 +6,8 @@
+ static char *test2(int cf) {
+   return cf ? 0 : "abc";
+ }
++
++int baz(void) {
++  int f;
++  return ((void)0, f = 1.4f); // expected-warning {{implicit conversion from 'float' to 'int' changes value from 1.4 to 1}}
++}
+diff -ruN --strip-trailing-cr a/clang/test/Sema/implicit-int-enum-conversion.c b/clang/test/Sema/implicit-int-enum-conversion.c
+--- a/clang/test/Sema/implicit-int-enum-conversion.c
++++ b/clang/test/Sema/implicit-int-enum-conversion.c
+@@ -50,3 +50,25 @@
+   return E2_Zero;       // expected-warning {{implicit conversion from enumeration type 'enum E2' to different enumeration type 'enum E1'}} \
+                            cxx-error {{cannot initialize return object of type 'enum E1' with an rvalue of type 'E2'}}
+ }
++
++enum E1 comma1(void) {
++  return ((void)0, E1_One);
++}
++
++enum E1 comma2(void) {
++  enum E1 x;
++  return
++    (x = 12,  // expected-warning {{implicit conversion from 'int' to enumeration type 'enum E1' is invalid in C++}} \
++                 cxx-error {{assigning to 'enum E1' from incompatible type 'int'}}
++    E1_One);
++}
++
++enum E1 comma3(void) {
++  enum E1 x;
++  return ((void)0, foo()); // Okay, no conversion in C++
++}
++
++enum E1 comma4(void) {
++  return ((void)1, 2); // expected-warning {{implicit conversion from 'int' to enumeration type 'enum E1' is invalid in C++}} \
++                          cxx-error {{cannot initialize return object of type 'enum E1' with an rvalue of type 'int'}}
++}

dependency_support/llvm/workspace.bzl

@@ -20,8 +20,8 @@ load("@bazel_tools//tools/build_defs/repo:utils.bzl", "maybe")
 def repo():
     """Initialize the llvm-project repository."""
 
-    LLVM_COMMIT = "7752e0a10b25da2f2eadbed10606bd5454dbca05"
-    LLVM_SHA256 = "1e67e67854bf00c07e5f876083cf7482d2ed4719b8d6595179a945f9c9f7ffe7"
+    LLVM_COMMIT = "2d287f51eff2a5fbf84458a33f7fb2493cf67965"
+    LLVM_SHA256 = "e06d0a35b0e0570b2f54dfd23d0e9fe6f084e032c14bb7ab194b06cb8c9cb86c"
 
     maybe(
         http_archive,