Merge from 'main' to 'sycl-web' (187 commits)

  CONFLICT (content): Merge conflict in clang/tools/clang-offload-bundler/ClangOffloadBundler.cpp

Author: smanna12

clang-tools-extra/clang-tidy/cppcoreguidelines/PreferMemberInitializerCheck.cpp

@@ -201,30 +201,42 @@ void PreferMemberInitializerCheck::check(
             diag(S->getBeginLoc(), "%0 should be initialized in an in-class"
                                    " default member initializer")
             << Field;
-        if (!InvalidFix) {
-          CharSourceRange StmtRange =
-              CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
-
-          SmallString<128> Insertion(
-              {UseAssignment ? " = " : "{",
-               Lexer::getSourceText(
-                   CharSourceRange(InitValue->getSourceRange(), true),
-                   *Result.SourceManager, getLangOpts()),
-               UseAssignment ? "" : "}"});
-
-          Diag << FixItHint::CreateInsertion(FieldEnd, Insertion)
-               << FixItHint::CreateRemoval(StmtRange);
-        }
+        if (InvalidFix)
+          continue;
+        CharSourceRange StmtRange =
+            CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
+
+        SmallString<128> Insertion(
+            {UseAssignment ? " = " : "{",
+             Lexer::getSourceText(
+                 CharSourceRange(InitValue->getSourceRange(), true),
+                 *Result.SourceManager, getLangOpts()),
+             UseAssignment ? "" : "}"});
+
+        Diag << FixItHint::CreateInsertion(FieldEnd, Insertion)
+             << FixItHint::CreateRemoval(StmtRange);
+
       } else {
         StringRef InsertPrefix = "";
+        bool HasInitAlready = false;
         SourceLocation InsertPos;
+        SourceRange ReplaceRange;
         bool AddComma = false;
         bool InvalidFix = false;
         unsigned Index = Field->getFieldIndex();
         const CXXCtorInitializer *LastInListInit = nullptr;
         for (const CXXCtorInitializer *Init : Ctor->inits()) {
-          if (!Init->isWritten())
+          if (!Init->isWritten() || Init->isInClassMemberInitializer())
             continue;
+          if (Init->getMember() == Field) {
+            HasInitAlready = true;
+            if (isa<ImplicitValueInitExpr>(Init->getInit()))
+              InsertPos = Init->getRParenLoc();
+            else {
+              ReplaceRange = Init->getInit()->getSourceRange();
+            }
+            break;
+          }
           if (Init->isMemberInitializer() &&
               Index < Init->getMember()->getFieldIndex()) {
             InsertPos = Init->getSourceLocation();
@@ -235,30 +247,38 @@ void PreferMemberInitializerCheck::check(
           }
           LastInListInit = Init;
         }
-        if (InsertPos.isInvalid()) {
-          if (LastInListInit) {
-            InsertPos = Lexer::getLocForEndOfToken(
-                LastInListInit->getRParenLoc(), 0, *Result.SourceManager,
-                getLangOpts());
-            // Inserting after the last constructor initializer, so we need a
-            // comma.
-            InsertPrefix = ", ";
-          } else {
-            InsertPos = Lexer::getLocForEndOfToken(
-                Ctor->getTypeSourceInfo()
-                    ->getTypeLoc()
-                    .getAs<clang::FunctionTypeLoc>()
-                    .getLocalRangeEnd(),
-                0, *Result.SourceManager, getLangOpts());
-
-            // If this is first time in the loop, there are no initializers so
-            // `:` declares member initialization list. If this is a subsequent
-            // pass then we have already inserted a `:` so continue with a
-            // comma.
-            InsertPrefix = FirstToCtorInits ? " : " : ", ";
+        if (HasInitAlready) {
+          if (InsertPos.isValid())
+            InvalidFix |= InsertPos.isMacroID();
+          else
+            InvalidFix |= ReplaceRange.getBegin().isMacroID() ||
+                          ReplaceRange.getEnd().isMacroID();
+        } else {
+          if (InsertPos.isInvalid()) {
+            if (LastInListInit) {
+              InsertPos = Lexer::getLocForEndOfToken(
+                  LastInListInit->getRParenLoc(), 0, *Result.SourceManager,
+                  getLangOpts());
+              // Inserting after the last constructor initializer, so we need a
+              // comma.
+              InsertPrefix = ", ";
+            } else {
+              InsertPos = Lexer::getLocForEndOfToken(
+                  Ctor->getTypeSourceInfo()
+                      ->getTypeLoc()
+                      .getAs<clang::FunctionTypeLoc>()
+                      .getLocalRangeEnd(),
+                  0, *Result.SourceManager, getLangOpts());
+
+              // If this is first time in the loop, there are no initializers so
+              // `:` declares member initialization list. If this is a
+              // subsequent pass then we have already inserted a `:` so continue
+              // with a comma.
+              InsertPrefix = FirstToCtorInits ? " : " : ", ";
+            }
           }
+          InvalidFix |= InsertPos.isMacroID();
         }
-        InvalidFix |= InsertPos.isMacroID();
 
         SourceLocation SemiColonEnd;
         if (auto NextToken = Lexer::findNextToken(
@@ -271,21 +291,25 @@ void PreferMemberInitializerCheck::check(
             diag(S->getBeginLoc(), "%0 should be initialized in a member"
                                    " initializer of the constructor")
             << Field;
-        if (!InvalidFix) {
-
-          CharSourceRange StmtRange =
-              CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd);
-          SmallString<128> Insertion(
-              {InsertPrefix, Field->getName(), "(",
-               Lexer::getSourceText(
-                   CharSourceRange(InitValue->getSourceRange(), true),
-                   *Result.SourceManager, getLangOpts()),
-               AddComma ? "), " : ")"});
+        if (InvalidFix)
+          continue;
+        StringRef NewInit = Lexer::getSourceText(
+            CharSourceRange(InitValue->getSourceRange(), true),
+            *Result.SourceManager, getLangOpts());
+        if (HasInitAlready) {
+          if (InsertPos.isValid())
+            Diag << FixItHint::CreateInsertion(InsertPos, NewInit);
+          else
+            Diag << FixItHint::CreateReplacement(ReplaceRange, NewInit);
+        } else {
+          SmallString<128> Insertion({InsertPrefix, Field->getName(), "(",
+                                      NewInit, AddComma ? "), " : ")"});
           Diag << FixItHint::CreateInsertion(InsertPos, Insertion,
-                                             FirstToCtorInits)
-               << FixItHint::CreateRemoval(StmtRange);
-          FirstToCtorInits = false;
+                                             FirstToCtorInits);
         }
+        Diag << FixItHint::CreateRemoval(
+            CharSourceRange::getCharRange(S->getBeginLoc(), SemiColonEnd));
+        FirstToCtorInits = false;
       }
     }
   }

clang-tools-extra/clang-tidy/performance/InefficientVectorOperationCheck.cpp

@@ -68,6 +68,10 @@ ast_matchers::internal::Matcher<Expr> supportedContainerTypesMatcher() {
       "::std::unordered_map", "::std::array", "::std::deque")));
 }
 
+AST_MATCHER(Expr, hasSideEffects) {
+  return Node.HasSideEffects(Finder->getASTContext());
+}
+
 } // namespace
 
 InefficientVectorOperationCheck::InefficientVectorOperationCheck(
@@ -145,7 +149,10 @@ void InefficientVectorOperationCheck::addMatcher(
   // FIXME: Support more complex range-expressions.
   Finder->addMatcher(
       cxxForRangeStmt(
-          hasRangeInit(declRefExpr(supportedContainerTypesMatcher())),
+          hasRangeInit(
+              anyOf(declRefExpr(supportedContainerTypesMatcher()),
+                    memberExpr(hasObjectExpression(unless(hasSideEffects())),
+                               supportedContainerTypesMatcher()))),
           HasInterestingLoopBody, InInterestingCompoundStmt)
           .bind(RangeLoopName),
       this);

clang-tools-extra/clangd/refactor/tweaks/ExtractFunction.cpp

@@ -479,6 +479,7 @@ std::string NewFunction::renderDeclaration(FunctionDeclKind K,
         llvm::formatv("{0} {\n{1}\n}\n", Declaration, getFuncBody(SM)));
     break;
   }
+  llvm_unreachable("Unsupported FunctionDeclKind enum");
 }
 
 std::string NewFunction::getFuncBody(const SourceManager &SM) const {

clang-tools-extra/docs/ReleaseNotes.rst

@@ -127,6 +127,10 @@ New check aliases
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+- Improved :doc:`performance-inefficient-vector-operation 
+  <clang-tidy/checks/performance-inefficient-vector-operation>` to work when
+  the vector is a member of a structure.
+
 - Fixed a false positive in :doc:`readability-non-const-parameter
   <clang-tidy/checks/readability-non-const-parameter>` when the parameter is referenced by an lvalue
 
@@ -139,6 +143,12 @@ Changes in existing checks
 
 - Fixed a crash in :doc:`bugprone-sizeof-expression <clang-tidy/checks/bugprone-sizeof-expression>` when
   `sizeof(...)` is compared agains a `__int128_t`.
+  
+- Improved :doc:`cppcoreguidelines-prefer-member-initializer
+  <clang-tidy/checks/cppcoreguidelines-prefer-member-initializer>` check.
+
+  Fixed an issue when there was already an initializer in the constructor and
+  the check would try to create another initializer for the same member.
 
 Removed checks
 ^^^^^^^^^^^^^^

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-prefer-member-initializer.cpp

@@ -526,14 +526,32 @@ struct InitFromVarDecl {
   }
 };
 
-struct AlreadyHasInit {
+struct HasInClassInit {
   int m = 4;
-  AlreadyHasInit() {
+  HasInClassInit() {
     m = 3;
     // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'm' should be initialized in a member initializer of the constructor
   }
 };
 
+struct HasInitListInit {
+  int M;
+  // CHECK-MESSAGES: :[[@LINE+5]]:5: warning: 'M' should be initialized in a member initializer of the constructor
+  // CHECK-FIXES: HasInitListInit(const HasInitListInit &Other) : M(Other.M) {
+  // CHECK-FIXES-NEXT: {{^    $}}
+  // CHECK-FIXES-NEXT: }
+  HasInitListInit(const HasInitListInit &Other) : M(4) {
+    M = Other.M;
+  }
+  // CHECK-MESSAGES: :[[@LINE+5]]:5: warning: 'M' should be initialized in a member initializer of the constructor
+  // CHECK-FIXES: HasInitListInit(HasInitListInit &&Other) : M(Other.M) {
+  // CHECK-FIXES-NEXT: {{^    $}}
+  // CHECK-FIXES-NEXT: }
+  HasInitListInit(HasInitListInit &&Other) : M() {
+    M = Other.M;
+  }
+};
+
 #define ASSIGN_IN_MACRO(FIELD, VALUE) FIELD = (VALUE);
 
 struct MacroCantFix {

clang-tools-extra/test/clang-tidy/checkers/performance-inefficient-vector-operation.cpp

@@ -44,7 +44,7 @@ class vector {
   void reserve(size_t n);
   void resize(size_t n);
 
-  size_t size();
+  size_t size() const;
   const_reference operator[] (size_type) const;
   reference operator[] (size_type);
 
@@ -359,3 +359,31 @@ void f(std::vector<int>& t) {
     }
   }
 }
+
+struct StructWithFieldContainer {
+  std::vector<int> Numbers;
+  std::vector<int> getNumbers() const {
+    std::vector<int> Result;
+    // CHECK-FIXES: Result.reserve(Numbers.size());
+    for (auto Number : Numbers) {
+      Result.push_back(Number);
+      // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: 'push_back' is called
+    }
+    return Result;
+  }
+};
+
+StructWithFieldContainer getStructWithField();
+
+void foo(const StructWithFieldContainer &Src) {
+  std::vector<int> A;
+  // CHECK-FIXES: A.reserve(Src.Numbers.size());
+  for (auto Number : Src.Numbers) {
+    A.push_back(Number);
+    // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: 'push_back' is called
+  }
+  std::vector<int> B;
+  for (auto Number : getStructWithField().Numbers) {
+    B.push_back(Number);
+  }
+}

clang/CMakeLists.txt

@@ -245,7 +245,7 @@ set(PPC_LINUX_DEFAULT_IEEELONGDOUBLE OFF CACHE BOOL
 set(CLANG_SPAWN_CC1 OFF CACHE BOOL
     "Whether clang should use a new process for the CC1 invocation")
 
-option(CLANG_DEFAULT_PIE_ON_LINUX "Default to -fPIE and -pie on linux-gnu" ON)
+option(CLANG_DEFAULT_PIE_ON_LINUX "Default to -fPIE and -pie on Linux" OFF)
 
 # Manually handle default so we can change the meaning of a cached default.
 set(CLANG_ENABLE_OPAQUE_POINTERS "DEFAULT" CACHE STRING

clang/docs/ClangCommandLineReference.rst

@@ -2093,10 +2093,6 @@ Emit OpenMP code only for SIMD-based constructs.
 
 Enable debugging in the OpenMP offloading device RTL
 
-.. option:: -fopenmp-target-new-runtime, -fno-openmp-target-new-runtime
-
-Use the new bitcode library for OpenMP offloading
-
 .. option:: -fopenmp-offload-mandatory
 
 Indicate that offloading to the device is mandatory and do not generate host-fallback code.

clang/docs/ReleaseNotes.rst

@@ -298,12 +298,6 @@ Internal API Changes
 Build System Changes
 --------------------
 
-* CMake ``-DCLANG_DEFAULT_PIE_ON_LINUX=ON`` is now the default. This is used by
-  linux-gnu systems to decide whether ``-fPIE -pie`` is the default (instead of
-  ``-fno-pic -no-pie``). This matches GCC installations on many Linux distros.
-  Note: linux-android and linux-musl always default to ``-fPIE -pie``, ignoring
-  this variable. ``-DCLANG_DEFAULT_PIE_ON_LINUX`` may be removed in the future.
-
 AST Matchers
 ------------
 

clang/include/clang/AST/DeclarationName.h

@@ -21,6 +21,7 @@
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/FoldingSet.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
@@ -192,6 +193,13 @@ class DeclarationName {
                 "The various classes that DeclarationName::Ptr can point to"
                 " must be at least aligned to 8 bytes!");
 
+  static_assert(
+      std::is_same<std::underlying_type_t<StoredNameKind>,
+                   std::underlying_type_t<
+                       detail::DeclarationNameExtra::ExtraKind>>::value,
+      "The various enums used to compute values for NameKind should "
+      "all have the same underlying type");
+
 public:
   /// The kind of the name stored in this DeclarationName.
   /// The first 7 enumeration values are stored inline and correspond
@@ -205,15 +213,18 @@ class DeclarationName {
     CXXDestructorName = StoredCXXDestructorName,
     CXXConversionFunctionName = StoredCXXConversionFunctionName,
     CXXOperatorName = StoredCXXOperatorName,
-    CXXDeductionGuideName = UncommonNameKindOffset +
-                            detail::DeclarationNameExtra::CXXDeductionGuideName,
-    CXXLiteralOperatorName =
-        UncommonNameKindOffset +
-        detail::DeclarationNameExtra::CXXLiteralOperatorName,
-    CXXUsingDirective = UncommonNameKindOffset +
-                        detail::DeclarationNameExtra::CXXUsingDirective,
-    ObjCMultiArgSelector = UncommonNameKindOffset +
-                           detail::DeclarationNameExtra::ObjCMultiArgSelector
+    CXXDeductionGuideName = llvm::addEnumValues(
+        UncommonNameKindOffset,
+        detail::DeclarationNameExtra::CXXDeductionGuideName),
+    CXXLiteralOperatorName = llvm::addEnumValues(
+        UncommonNameKindOffset,
+        detail::DeclarationNameExtra::CXXLiteralOperatorName),
+    CXXUsingDirective =
+        llvm::addEnumValues(UncommonNameKindOffset,
+                            detail::DeclarationNameExtra::CXXUsingDirective),
+    ObjCMultiArgSelector =
+        llvm::addEnumValues(UncommonNameKindOffset,
+                            detail::DeclarationNameExtra::ObjCMultiArgSelector),
   };
 
 private: