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

  CONFLICT (content): Merge conflict in llvm/lib/Transforms/IPO/PassManagerBuilder.cpp
  CONFLICT (content): Merge conflict in llvm/lib/Passes/PassBuilderPipelines.cpp

Author: AlexeySachkov

bolt/lib/Core/BinaryContext.cpp

@@ -2036,9 +2036,9 @@ void BinaryContext::renameSection(BinarySection &Section,
   deregisterSectionName(Section);
 
   Section.Name = NewName.str();
-  Section.setOutputName(NewName);
+  Section.setOutputName(Section.Name);
 
-  NameToSection.insert(std::make_pair(NewName.str(), &Section));
+  NameToSection.insert(std::make_pair(Section.Name, &Section));
 
   // Reinsert with the new name.
   Sections.insert(&Section);

clang-tools-extra/clangd/Headers.cpp

@@ -15,6 +15,7 @@
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Tooling/Inclusions/HeaderAnalysis.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Path.h"
 #include <cstring>
@@ -121,12 +122,10 @@ class IncludeStructure::RecordHeaders : public PPCallbacks,
         // isSelfContainedHeader only returns true once the full header-guard
         // structure has been seen, i.e. when exiting the *outer* copy of the
         // file. So last result wins.
-        if (isSelfContainedHeader(FE, PrevFID, SM, HeaderInfo))
-          Out->NonSelfContained.erase(
-              *Out->getID(SM.getFileEntryForID(PrevFID)));
+        if (tooling::isSelfContainedHeader(FE, SM, HeaderInfo))
+          Out->NonSelfContained.erase(*Out->getID(FE));
         else
-          Out->NonSelfContained.insert(
-              *Out->getID(SM.getFileEntryForID(PrevFID)));
+          Out->NonSelfContained.insert(*Out->getID(FE));
       }
       break;
     }

clang-tools-extra/clangd/SourceCode.cpp

@@ -1183,58 +1183,5 @@ bool isProtoFile(SourceLocation Loc, const SourceManager &SM) {
   return SM.getBufferData(FID).startswith(ProtoHeaderComment);
 }
 
-namespace {
-
-// Is Line an #if or #ifdef directive?
-// FIXME: This makes headers with #ifdef LINUX/WINDOWS/MACOS marked as non
-// self-contained and is probably not what we want.
-bool isIf(llvm::StringRef Line) {
-  Line = Line.ltrim();
-  if (!Line.consume_front("#"))
-    return false;
-  Line = Line.ltrim();
-  return Line.startswith("if");
-}
-
-// Is Line an #error directive mentioning includes?
-bool isErrorAboutInclude(llvm::StringRef Line) {
-  Line = Line.ltrim();
-  if (!Line.consume_front("#"))
-    return false;
-  Line = Line.ltrim();
-  if (!Line.startswith("error"))
-    return false;
-  return Line.contains_insensitive(
-      "includ"); // Matches "include" or "including".
-}
-
-// Heuristically headers that only want to be included via an umbrella.
-bool isDontIncludeMeHeader(llvm::StringRef Content) {
-  llvm::StringRef Line;
-  // Only sniff up to 100 lines or 10KB.
-  Content = Content.take_front(100 * 100);
-  for (unsigned I = 0; I < 100 && !Content.empty(); ++I) {
-    std::tie(Line, Content) = Content.split('\n');
-    if (isIf(Line) && isErrorAboutInclude(Content.split('\n').first))
-      return true;
-  }
-  return false;
-}
-
-} // namespace
-
-bool isSelfContainedHeader(const FileEntry *FE, FileID FID,
-                           const SourceManager &SM, HeaderSearch &HeaderInfo) {
-  // FIXME: Should files that have been #import'd be considered
-  // self-contained? That's really a property of the includer,
-  // not of the file.
-  if (!HeaderInfo.isFileMultipleIncludeGuarded(FE) &&
-      !HeaderInfo.hasFileBeenImported(FE))
-    return false;
-  // This pattern indicates that a header can't be used without
-  // particular preprocessor state, usually set up by another header.
-  return !isDontIncludeMeHeader(SM.getBufferData(FID));
-}
-
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/SourceCode.h

@@ -325,11 +325,6 @@ bool isHeaderFile(llvm::StringRef FileName,
 /// Returns true if the given location is in a generated protobuf file.
 bool isProtoFile(SourceLocation Loc, const SourceManager &SourceMgr);
 
-/// This scans source code, and should not be called when using a preamble.
-/// Prefer to access the cache in IncludeStructure::isSelfContained if you can.
-bool isSelfContainedHeader(const FileEntry *FE, FileID ID,
-                           const SourceManager &SM, HeaderSearch &HeaderInfo);
-
 /// Returns true if Name is reserved, like _Foo or __Vector_base.
 inline bool isReservedName(llvm::StringRef Name) {
   // This doesn't catch all cases, but the most common.

clang-tools-extra/clangd/index/SymbolCollector.cpp

@@ -28,6 +28,7 @@
 #include "clang/Index/IndexSymbol.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Token.h"
+#include "clang/Tooling/Inclusions/HeaderAnalysis.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/FileSystem.h"
@@ -419,8 +420,8 @@ class SymbolCollector::HeaderFileURICache {
                 getFrameworkHeaderIncludeSpelling(FE, HFI->Framework, HS))
           return *Spelling;
 
-    if (!isSelfContainedHeader(FE, FID, PP->getSourceManager(),
-                               PP->getHeaderSearchInfo())) {
+    if (!tooling::isSelfContainedHeader(FE, PP->getSourceManager(),
+                                        PP->getHeaderSearchInfo())) {
       // A .inc or .def file is often included into a real header to define
       // symbols (e.g. LLVM tablegen files).
       if (Filename.endswith(".inc") || Filename.endswith(".def"))

clang/bindings/python/clang/cindex.py

@@ -1504,6 +1504,31 @@ class Bar {
         """
         return conf.lib.clang_CXXMethod_isCopyAssignmentOperator(self)
 
+    def is_move_assignment_operator_method(self):
+        """Returnrs True if the cursor refers to a move-assignment operator.
+
+        A move-assignment operator `X::operator=` is a non-static,
+        non-template member function of _class_ `X` with exactly one
+        parameter of type `X&&`, `const X&&`, `volatile X&&` or `const
+        volatile X&&`.
+
+
+        That is, for example, the `operator=` in:
+
+           class Foo {
+               bool operator=(const volatile Foo&&);
+           };
+
+        Is a move-assignment operator, while the `operator=` in:
+
+           class Bar {
+               bool operator=(const int&&);
+           };
+
+        Is not.
+        """
+        return conf.lib.clang_CXXMethod_isMoveAssignmentOperator(self)
+
     def is_mutable_field(self):
         """Returns True if the cursor refers to a C++ field that is declared
         'mutable'.
@@ -3465,6 +3490,10 @@ def cursor(self):
    [Cursor],
    bool),
 
+  ("clang_CXXMethod_isMoveAssignmentOperator",
+   [Cursor],
+   bool),
+
   ("clang_CXXMethod_isPureVirtual",
    [Cursor],
    bool),

clang/bindings/python/tests/cindex/test_cursor.py

@@ -219,6 +219,64 @@ def test_is_default_method(self):
         self.assertTrue(xc.is_default_method())
         self.assertFalse(yc.is_default_method())
 
+    def test_is_move_assignment_operator_method(self):
+        """Ensure Cursor.is_move_assignment_operator_method works."""
+        source_with_move_assignment_operators = """
+        struct Foo {
+           // Those are move-assignment operators
+           bool operator=(const Foo&&);
+           bool operator=(Foo&&);
+           bool operator=(volatile Foo&&);
+           bool operator=(const volatile Foo&&);
+
+        // Positive-check that the recognition works for templated classes too
+        template <typename T>
+        class Bar {
+            bool operator=(const Bar&&);
+            bool operator=(Bar<T>&&);
+            bool operator=(volatile Bar&&);
+            bool operator=(const volatile Bar<T>&&);
+        };
+        """
+        source_without_move_assignment_operators = """
+        struct Foo {
+            // Those are not move-assignment operators
+            template<typename T>
+            bool operator=(const T&&);
+            bool operator=(const bool&&);
+            bool operator=(char&&);
+            bool operator=(volatile unsigned int&&);
+            bool operator=(const volatile unsigned char&&);
+            bool operator=(int);
+            bool operator=(Foo);
+        };
+        """
+        tu_with_move_assignment_operators = get_tu(
+            source_with_move_assignment_operators, lang="cpp"
+        )
+        tu_without_move_assignment_operators = get_tu(
+            source_without_move_assignment_operators, lang="cpp"
+        )
+
+        move_assignment_operators_cursors = get_cursors(
+            tu_with_move_assignment_operators, "operator="
+        )
+        non_move_assignment_operators_cursors = get_cursors(
+            tu_without_move_assignment_operators, "operator="
+        )
+
+        self.assertEqual(len(move_assignment_operators_cursors), 8)
+        self.assertTrue(len(non_move_assignment_operators_cursors), 7)
+
+        self.assertTrue(all([
+            cursor.is_move_assignment_operator_method()
+            for cursor in move_assignment_operators_cursors
+        ]))
+        self.assertFalse(any([
+            cursor.is_move_assignment_operator_method()
+            for cursor in non_move_assignment_operators_cursors
+        ]))
+
     def test_is_mutable_field(self):
         """Ensure Cursor.is_mutable_field works."""
         source = 'class X { int x_; mutable int y_; };'

clang/docs/ReleaseNotes.rst

@@ -792,6 +792,9 @@ libclang
 - Introduced the new function ``clang_CXXMethod_isCopyAssignmentOperator``,
   which identifies whether a method cursor is a copy-assignment
   operator.
+- Introduced the new function ``clang_CXXMethod_isMoveAssignmentOperator``,
+  which identifies whether a method cursor is a move-assignment
+  operator.
 - ``clang_Cursor_getNumTemplateArguments``, ``clang_Cursor_getTemplateArgumentKind``, 
   ``clang_Cursor_getTemplateArgumentType``, ``clang_Cursor_getTemplateArgumentValue`` and 
   ``clang_Cursor_getTemplateArgumentUnsignedValue`` now work on struct, class,

clang/include/clang-c/Index.h

@@ -2080,23 +2080,6 @@ enum CXCursorKind {
   CXCursor_OverloadCandidate = 700
 };
 
-/**
- * Describes the kind of result generated.
- */
-enum CXCompletionResultKind {
-  /** Refers to a declaration. */
-  CXCompletionResult_Declaration = 0,
-
-  /** Refers to a keyword or symbol. */
-  CXCompletionResult_Keyword = 1,
-
-  /** Refers to a macro. */
-  CXCompletionResult_Macro = 2,
-
-  /** Refers to a precomputed pattern. */
-  CXCompletionResult_Pattern = 3
-};
-
 /**
  * A cursor representing some element in the abstract syntax tree for
  * a translation unit.
@@ -4343,6 +4326,31 @@ CINDEX_LINKAGE unsigned clang_CXXMethod_isVirtual(CXCursor C);
  */
 CINDEX_LINKAGE unsigned clang_CXXMethod_isCopyAssignmentOperator(CXCursor C);
 
+/**
+ * Determine if a C++ member function is a move-assignment operator,
+ * returning 1 if such is the case and 0 otherwise.
+ *
+ * > A move-assignment operator `X::operator=` is a non-static,
+ * > non-template member function of _class_ `X` with exactly one
+ * > parameter of type `X&&`, `const X&&`, `volatile X&&` or `const
+ * > volatile X&&`.
+ *
+ * That is, for example, the `operator=` in:
+ *
+ *    class Foo {
+ *        bool operator=(const volatile Foo&&);
+ *    };
+ *
+ * Is a move-assignment operator, while the `operator=` in:
+ *
+ *    class Bar {
+ *        bool operator=(const int&&);
+ *    };
+ *
+ * Is not.
+ */
+CINDEX_LINKAGE unsigned clang_CXXMethod_isMoveAssignmentOperator(CXCursor C);
+
 /**
  * Determine if a C++ record is abstract, i.e. whether a class or struct
  * has a pure virtual member function.
@@ -4619,8 +4627,6 @@ CINDEX_LINKAGE void clang_disposeTokens(CXTranslationUnit TU, CXToken *Tokens,
  */
 
 /* for debug/testing */
-CINDEX_LINKAGE CXString
-clang_getCompletionResultKindSpelling(enum CXCompletionResultKind Kind);
 CINDEX_LINKAGE CXString clang_getCursorKindSpelling(enum CXCursorKind Kind);
 CINDEX_LINKAGE void clang_getDefinitionSpellingAndExtent(
     CXCursor, const char **startBuf, const char **endBuf, unsigned *startLine,
@@ -4664,17 +4670,12 @@ typedef void *CXCompletionString;
  * A single result of code completion.
  */
 typedef struct {
-  /**
-   * The kind of this completion result.
-   * Useful to distinguish between declarations and keywords.
-   */
-  enum CXCompletionResultKind ResultKind;
-
   /**
    * The kind of entity that this completion refers to.
    *
-   * The cursor kind will be a macro or a declaration (one of the *Decl cursor
-   * kinds), describing the entity that the completion is referring to.
+   * The cursor kind will be a macro, keyword, or a declaration (one of the
+   * *Decl cursor kinds), describing the entity that the completion is
+   * referring to.
    *
    * \todo In the future, we would like to provide a full cursor, to allow
    * the client to extract additional information from declaration.

clang/include/clang/Basic/AttrDocs.td

@@ -7374,7 +7374,7 @@ by showing the control-flow statement where the path diverges.
     if (somePredicate()) {
       ...
       callback();
-    } esle {
+    } else {
       callback(); // OK: callback is called on every path
     }
   }